{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "923c1ec6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集前五行：\n",
      "   ID  Sepal.Length  Sepal.Width  Petal.Length  Petal.Width Species\n",
      "0   1           5.1          3.5           1.4          0.2  setosa\n",
      "1   2           4.9          3.0           1.4          0.2  setosa\n",
      "2   3           4.7          3.2           1.3          0.2  setosa\n",
      "3   4           4.6          3.1           1.5          0.2  setosa\n",
      "4   5           5.0          3.6           1.4          0.2  setosa\n",
      "\n",
      "标签编码示例：\n",
      "[0 0 0 0 0 0 0 0 0 0]\n",
      "\n",
      "训练集大小: (105, 5)\n",
      "测试集大小: (45, 5)\n"
     ]
    }
   ],
   "source": [
    "# 导入必要的库\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
    "\n",
    "# 读取 Iris 数据集\n",
    "iris = pd.read_csv('./Iris.csv')\n",
    "\n",
    "# 查看数据的前几行\n",
    "print(\"数据集前五行：\")\n",
    "print(iris.head())\n",
    "\n",
    "# 提取特征和标签\n",
    "# 假设最后一列是 'Species'\n",
    "X = iris.iloc[:, :-1]  # 特征：除最后一列外的所有列\n",
    "y = iris.iloc[:, -1]   # 标签：最后一列\n",
    "\n",
    "# 将字符串标签转换为数值型标签\n",
    "le = LabelEncoder()\n",
    "y_encoded = le.fit_transform(y)\n",
    "\n",
    "# 查看标签编码\n",
    "print(\"\\n标签编码示例：\")\n",
    "print(y_encoded[:10])\n",
    "\n",
    "# 划分训练集和测试集（70% 训练，30% 测试）\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y_encoded, test_size=0.3, random_state=42, stratify=y_encoded\n",
    ")\n",
    "\n",
    "print(f\"\\n训练集大小: {X_train.shape}\")\n",
    "print(f\"测试集大小: {X_test.shape}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec1c8d5f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7dcc024b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "标准化后的训练数据前五行：\n",
      "[[ 0.53726272 -0.90045861 -1.22024754 -0.4419858  -0.13661044]\n",
      " [-0.15718848  0.38036614 -1.87955796  0.40282929  0.38029394]\n",
      " [-1.29145876 -0.90045861  1.63676428 -1.2868009  -1.17041921]\n",
      " [ 1.57893951  1.07899781  0.31814344  1.19132338  1.41410271]\n",
      " [ 0.56041109 -0.20182693 -0.56093712  0.17754527  0.12184175]]\n"
     ]
    }
   ],
   "source": [
    "# 导入标准化处理库\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# 创建标准化对象\n",
    "scaler = StandardScaler()\n",
    "\n",
    "# 对训练集进行拟合和变换\n",
    "X_train_scaled = scaler.fit_transform(X_train)\n",
    "\n",
    "# 对测试集进行变换\n",
    "X_test_scaled = scaler.transform(X_test)\n",
    "\n",
    "# 查看标准化后的数据\n",
    "print(\"\\n标准化后的训练数据前五行：\")\n",
    "print(X_train_scaled[:5])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "546c5a35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "线性回归模型的均方误差 (MSE): 0.00\n",
      "线性回归模型的决定系数 (R²): 1.00\n"
     ]
    }
   ],
   "source": [
    "# 导入线性回归模型\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "\n",
    "# 假设我们预测 'petal_width'\n",
    "X_lr = X_train_scaled  # 使用所有特征\n",
    "y_lr = y_train  # 实际上，这是分类标签，通常线性回归用于回归任务\n",
    "\n",
    "# 由于 y_train 是分类标签，我们需要选择一个数值型目标\n",
    "# 这里我们选择 'petal_width' 作为目标\n",
    "y_lr = X_train['Petal.Width']\n",
    "\n",
    "# 重新划分特征和目标\n",
    "X_lr = X_train_scaled\n",
    "y_lr = X_train['Petal.Width']\n",
    "\n",
    "# 创建线性回归模型\n",
    "lr_model = LinearRegression()\n",
    "\n",
    "# 训练模型\n",
    "lr_model.fit(X_lr, y_lr)\n",
    "\n",
    "# 预测\n",
    "y_pred_lr = lr_model.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "mse = mean_squared_error(X_test['Petal.Width'], y_pred_lr)\n",
    "r2 = r2_score(X_test['Petal.Width'], y_pred_lr)\n",
    "\n",
    "print(f\"\\n线性回归模型的均方误差 (MSE): {mse:.2f}\")\n",
    "print(f\"线性回归模型的决定系数 (R²): {r2:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "41a52091",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ridge 回归的均方误差 (MSE): 0.04621134785546967\n",
      "Lasso 回归的均方误差 (MSE): 0.05175534674071506\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import Ridge, Lasso\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "# 假设你的数据集已经读取\n",
    "data = iris\n",
    "\n",
    "# 选择特征和目标值\n",
    "X = data[['Sepal.Length', 'Sepal.Width', 'Petal.Length']]  # 特征\n",
    "y = data['Petal.Width']  # 目标值\n",
    "\n",
    "# 分割训练集和测试集\n",
    "X_train_lr, X_test_lr, y_lr, y_test_lr = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# 设置 alpha 值\n",
    "alpha = 0.1  # alpha 是正则化强度，越大正则化效果越强\n",
    "\n",
    "# 训练 Ridge 回归模型\n",
    "ridge_model = Ridge(alpha=alpha)\n",
    "ridge_model.fit(X_train_lr, y_lr)\n",
    "\n",
    "# 预测 Ridge 模型\n",
    "y_pred_ridge = ridge_model.predict(X_test_lr)\n",
    "\n",
    "# 计算 Ridge 模型的均方误差\n",
    "mse_ridge = mean_squared_error(y_test_lr, y_pred_ridge)\n",
    "print(f\"Ridge 回归的均方误差 (MSE): {mse_ridge}\")\n",
    "\n",
    "# 训练 Lasso 回归模型\n",
    "lasso_model = Lasso(alpha=alpha)\n",
    "lasso_model.fit(X_train_lr, y_lr)\n",
    "\n",
    "# 预测 Lasso 模型\n",
    "y_pred_lasso = lasso_model.predict(X_test_lr)\n",
    "\n",
    "# 计算 Lasso 模型的均方误差\n",
    "mse_lasso = mean_squared_error(y_test_lr, y_pred_lasso)\n",
    "print(f\"Lasso 回归的均方误差 (MSE): {mse_lasso}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "73c673c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "决策树分类器的准确率: 1.00\n",
      "决策树分类器的混淆矩阵：\n",
      "[[15  0  0]\n",
      " [ 0 15  0]\n",
      " [ 0  0 15]]\n",
      "决策树分类器的分类报告：\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "      setosa       1.00      1.00      1.00        15\n",
      "  versicolor       1.00      1.00      1.00        15\n",
      "   virginica       1.00      1.00      1.00        15\n",
      "\n",
      "    accuracy                           1.00        45\n",
      "   macro avg       1.00      1.00      1.00        45\n",
      "weighted avg       1.00      1.00      1.00        45\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 导入决策树分类器\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
    "\n",
    "# 创建决策树模型\n",
    "dt_model = DecisionTreeClassifier(random_state=42)\n",
    "\n",
    "# 训练模型\n",
    "dt_model.fit(X_train_scaled, y_train)\n",
    "\n",
    "# 预测测试集\n",
    "y_pred_dt = dt_model.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "accuracy_dt = accuracy_score(y_test, y_pred_dt)\n",
    "cm_dt = confusion_matrix(y_test, y_pred_dt)\n",
    "report_dt = classification_report(y_test, y_pred_dt, target_names=le.classes_)\n",
    "\n",
    "print(f\"\\n决策树分类器的准确率: {accuracy_dt:.2f}\")\n",
    "print(\"决策树分类器的混淆矩阵：\")\n",
    "print(cm_dt)\n",
    "print(\"决策树分类器的分类报告：\")\n",
    "print(report_dt)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5f62bdc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "决策树最佳参数: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2}\n",
      "调参后决策树分类器的准确率: 1.00\n"
     ]
    }
   ],
   "source": [
    "# 使用 GridSearchCV 进行超参数调优\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# 定义参数网格\n",
    "param_grid = {\n",
    "    'max_depth': [None, 2, 4, 6, 8],\n",
    "    'min_samples_split': [2, 5, 10],\n",
    "    'min_samples_leaf': [1, 2, 4]\n",
    "}\n",
    "\n",
    "# 创建 GridSearchCV 对象\n",
    "grid_search_dt = GridSearchCV(\n",
    "    estimator=DecisionTreeClassifier(random_state=42),\n",
    "    param_grid=param_grid,\n",
    "    cv=5,\n",
    "    scoring='accuracy',\n",
    "    n_jobs=-1\n",
    ")\n",
    "\n",
    "# 执行网格搜索\n",
    "grid_search_dt.fit(X_train_scaled, y_train)\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"\\n决策树最佳参数: {grid_search_dt.best_params_}\")\n",
    "\n",
    "# 使用最佳参数进行预测\n",
    "y_pred_dt_best = grid_search_dt.best_estimator_.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "accuracy_dt_best = accuracy_score(y_test, y_pred_dt_best)\n",
    "print(f\"调参后决策树分类器的准确率: {accuracy_dt_best:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46637534",
   "metadata": {},
   "source": [
    " 随机森林分类器：RandomForestClassifier\n",
    "随机森林通过构建多个决策树来提高分类性能和稳定性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e66f0ce7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "随机森林分类器的准确率: 1.00\n",
      "随机森林分类器的混淆矩阵：\n",
      "[[15  0  0]\n",
      " [ 0 15  0]\n",
      " [ 0  0 15]]\n",
      "随机森林分类器的分类报告：\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "      setosa       1.00      1.00      1.00        15\n",
      "  versicolor       1.00      1.00      1.00        15\n",
      "   virginica       1.00      1.00      1.00        15\n",
      "\n",
      "    accuracy                           1.00        45\n",
      "   macro avg       1.00      1.00      1.00        45\n",
      "weighted avg       1.00      1.00      1.00        45\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 导入随机森林分类器\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# 创建随机森林分类器\n",
    "rf_model = RandomForestClassifier(random_state=42)\n",
    "\n",
    "# 训练模型\n",
    "rf_model.fit(X_train_scaled, y_train)\n",
    "\n",
    "# 预测测试集\n",
    "y_pred_rf = rf_model.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "accuracy_rf = accuracy_score(y_test, y_pred_rf)\n",
    "cm_rf = confusion_matrix(y_test, y_pred_rf)\n",
    "report_rf = classification_report(y_test, y_pred_rf, target_names=le.classes_)\n",
    "\n",
    "print(f\"\\n随机森林分类器的准确率: {accuracy_rf:.2f}\")\n",
    "print(\"随机森林分类器的混淆矩阵：\")\n",
    "print(cm_rf)\n",
    "print(\"随机森林分类器的分类报告：\")\n",
    "print(report_rf)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d5cc91b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "随机森林最佳参数: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}\n",
      "调参后随机森林分类器的准确率: 1.00\n"
     ]
    }
   ],
   "source": [
    "# 使用 GridSearchCV 进行超参数调优\n",
    "param_grid_rf = {\n",
    "    'n_estimators': [100, 200, 300],\n",
    "    'max_depth': [None, 4, 6, 8],\n",
    "    'min_samples_split': [2, 5, 10],\n",
    "    'min_samples_leaf': [1, 2, 4]\n",
    "}\n",
    "\n",
    "grid_search_rf = GridSearchCV(\n",
    "    estimator=RandomForestClassifier(random_state=42),\n",
    "    param_grid=param_grid_rf,\n",
    "    cv=5,\n",
    "    scoring='accuracy',\n",
    "    n_jobs=-1\n",
    ")\n",
    "\n",
    "# 执行网格搜索\n",
    "grid_search_rf.fit(X_train_scaled, y_train)\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"\\n随机森林最佳参数: {grid_search_rf.best_params_}\")\n",
    "\n",
    "# 使用最佳参数进行预测\n",
    "y_pred_rf_best = grid_search_rf.best_estimator_.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "accuracy_rf_best = accuracy_score(y_test, y_pred_rf_best)\n",
    "print(f\"调参后随机森林分类器的准确率: {accuracy_rf_best:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "82e4b03c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "支持向量机分类器的准确率: 1.00\n",
      "支持向量机分类器的混淆矩阵：\n",
      "[[15  0  0]\n",
      " [ 0 15  0]\n",
      " [ 0  0 15]]\n",
      "支持向量机分类器的分类报告：\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "      setosa       1.00      1.00      1.00        15\n",
      "  versicolor       1.00      1.00      1.00        15\n",
      "   virginica       1.00      1.00      1.00        15\n",
      "\n",
      "    accuracy                           1.00        45\n",
      "   macro avg       1.00      1.00      1.00        45\n",
      "weighted avg       1.00      1.00      1.00        45\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 导入支持向量机分类器\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# 创建支持向量机分类器\n",
    "svc_model = SVC(random_state=42)\n",
    "\n",
    "# 训练模型\n",
    "svc_model.fit(X_train_scaled, y_train)\n",
    "\n",
    "# 预测测试集\n",
    "y_pred_svc = svc_model.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "accuracy_svc = accuracy_score(y_test, y_pred_svc)\n",
    "cm_svc = confusion_matrix(y_test, y_pred_svc)\n",
    "report_svc = classification_report(y_test, y_pred_svc, target_names=le.classes_)\n",
    "\n",
    "print(f\"\\n支持向量机分类器的准确率: {accuracy_svc:.2f}\")\n",
    "print(\"支持向量机分类器的混淆矩阵：\")\n",
    "print(cm_svc)\n",
    "print(\"支持向量机分类器的分类报告：\")\n",
    "print(report_svc)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3abf5635",
   "metadata": {},
   "source": [
    "调参细节：\n",
    "\n",
    "C：惩罚参数，控制误分类的惩罚强度。较大的 C 值会尝试更好地分类训练数据，但可能导致过拟合。\n",
    "kernel：核函数类型，如 'linear'、'rbf'、'poly' 等，不同核函数适用于不同的数据分布。\n",
    "gamma：核函数的系数，影响决策边界的灵活性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0be3d63f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "支持向量机最佳参数: {'C': 0.1, 'gamma': 'scale', 'kernel': 'linear'}\n",
      "调参后支持向量机分类器的准确率: 0.98\n"
     ]
    }
   ],
   "source": [
    "# 使用 GridSearchCV 进行超参数调优\n",
    "param_grid_svc = {\n",
    "    'C': [0.1, 1, 10, 100],\n",
    "    'kernel': ['linear', 'rbf', 'poly'],\n",
    "    'gamma': ['scale', 'auto']\n",
    "}\n",
    "\n",
    "grid_search_svc = GridSearchCV(\n",
    "    estimator=SVC(random_state=42),\n",
    "    param_grid=param_grid_svc,\n",
    "    cv=5,\n",
    "    scoring='accuracy',\n",
    "    n_jobs=-1\n",
    ")\n",
    "\n",
    "# 执行网格搜索\n",
    "grid_search_svc.fit(X_train_scaled, y_train)\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"\\n支持向量机最佳参数: {grid_search_svc.best_params_}\")\n",
    "\n",
    "# 使用最佳参数进行预测\n",
    "y_pred_svc_best = grid_search_svc.best_estimator_.predict(X_test_scaled)\n",
    "\n",
    "# 评估模型\n",
    "accuracy_svc_best = accuracy_score(y_test, y_pred_svc_best)\n",
    "print(f\"调参后支持向量机分类器的准确率: {accuracy_svc_best:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5c904b64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "随机森林调参后模型的准确率: 1.00\n",
      "混淆矩阵：\n",
      "[[15  0  0]\n",
      " [ 0 15  0]\n",
      " [ 0  0 15]]\n",
      "分类报告：\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "      setosa       1.00      1.00      1.00        15\n",
      "  versicolor       1.00      1.00      1.00        15\n",
      "   virginica       1.00      1.00      1.00        15\n",
      "\n",
      "    accuracy                           1.00        45\n",
      "   macro avg       1.00      1.00      1.00        45\n",
      "weighted avg       1.00      1.00      1.00        45\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 导入评估方法\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
    "\n",
    "# 计算准确率\n",
    "accuracy = accuracy_score(y_test, y_pred_rf_best)\n",
    "print(f\"\\n随机森林调参后模型的准确率: {accuracy:.2f}\")\n",
    "\n",
    "# 打印混淆矩阵\n",
    "cm = confusion_matrix(y_test, y_pred_rf_best)\n",
    "print(\"混淆矩阵：\")\n",
    "print(cm)\n",
    "\n",
    "# 打印分类报告\n",
    "report = classification_report(y_test, y_pred_rf_best, target_names=le.classes_)\n",
    "print(\"分类报告：\")\n",
    "print(report)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4ba1854",
   "metadata": {},
   "source": [
    "准确率 (accuracy_score)：分类正确的样本比例。\n",
    "混淆矩阵 (confusion_matrix)：展示真实标签与预测标签的对应关系。\n",
    "分类报告 (classification_report)：包含精准率、召回率和 F1 分数等详细指标。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "54feaa28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "每个主成分解释的方差比例: [0.74945324 0.18712459]\n",
      "累计解释的方差比例: [0.74945324 0.93657783]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入 PCA\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "# 创建 PCA 对象，降到2个主成分\n",
    "pca = PCA(n_components=2)\n",
    "\n",
    "# 拟合 PCA 并转换数据\n",
    "X_pca = pca.fit_transform(X_train_scaled)\n",
    "\n",
    "# 查看主成分解释的方差比例\n",
    "print(f\"\\n每个主成分解释的方差比例: {pca.explained_variance_ratio_}\")\n",
    "print(f\"累计解释的方差比例: {pca.explained_variance_ratio_.cumsum()}\")\n",
    "\n",
    "# 可视化主成分\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# 创建一个 DataFrame 存储 PCA 结果\n",
    "pca_df = pd.DataFrame(data=X_pca, columns=['PC1', 'PC2'])\n",
    "pca_df['Species'] = y_train\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.scatterplot(x='PC1', y='PC2', hue='Species', data=pca_df, palette='viridis')\n",
    "plt.title('PCA of Iris Dataset')\n",
    "plt.xlabel('Principal Component 1')\n",
    "plt.ylabel('Principal Component 2')\n",
    "plt.legend(title='Species')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4622c62",
   "metadata": {},
   "source": [
    "调参细节：\n",
    "\n",
    "n_components：选择主成分的数量，通常基于累计解释的方差比例。\n",
    "说明：\n",
    "\n",
    "PCA 可以帮助减少特征数量，同时保留数据中大部分的变异性。\n",
    "可视化 PCA 结果有助于理解数据的分布和类别分离情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "96a3c3e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "K-Means 调整兰德指数 (ARI): 0.67\n"
     ]
    }
   ],
   "source": [
    "# 导入 K-Means\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "# 创建 K-Means 对象，设置为3个簇\n",
    "kmeans = KMeans(n_clusters=3, random_state=42)\n",
    "\n",
    "# 训练模型\n",
    "kmeans.fit(X_train_scaled)\n",
    "\n",
    "# 预测簇标签\n",
    "y_kmeans = kmeans.predict(X_test_scaled)\n",
    "\n",
    "# 评估聚类效果（使用调整兰德指数）\n",
    "from sklearn.metrics import adjusted_rand_score\n",
    "\n",
    "ari = adjusted_rand_score(y_test, y_kmeans)\n",
    "print(f\"\\nK-Means 调整兰德指数 (ARI): {ari:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2b090ab3",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 32920 (\\N{CJK UNIFIED IDEOGRAPH-8098}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 37096 (\\N{CJK UNIFIED IDEOGRAPH-90E8}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 27861 (\\N{CJK UNIFIED IDEOGRAPH-6CD5}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 21017 (\\N{CJK UNIFIED IDEOGRAPH-5219}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 30830 (\\N{CJK UNIFIED IDEOGRAPH-786E}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 23450 (\\N{CJK UNIFIED IDEOGRAPH-5B9A}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 26368 (\\N{CJK UNIFIED IDEOGRAPH-6700}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 20339 (\\N{CJK UNIFIED IDEOGRAPH-4F73}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 31751 (\\N{CJK UNIFIED IDEOGRAPH-7C07}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 25968 (\\N{CJK UNIFIED IDEOGRAPH-6570}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 30340 (\\N{CJK UNIFIED IDEOGRAPH-7684}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 37327 (\\N{CJK UNIFIED IDEOGRAPH-91CF}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 24815 (\\N{CJK UNIFIED IDEOGRAPH-60EF}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n",
      "D:\\Anaconda3\\envs\\mathjian\\lib\\site-packages\\IPython\\core\\pylabtools.py:151: UserWarning: Glyph 24615 (\\N{CJK UNIFIED IDEOGRAPH-6027}) missing from current font.\n",
      "  fig.canvas.print_figure(bytes_io, **kw)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入库\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 计算不同簇数的惯性（簇内误差平方和）\n",
    "inertia = []\n",
    "k_range = range(1, 11)\n",
    "for k in k_range:\n",
    "    kmeans = KMeans(n_clusters=k, random_state=42)\n",
    "    kmeans.fit(X_train_scaled)\n",
    "    inertia.append(kmeans.inertia_)\n",
    "\n",
    "# 绘制肘部图\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(k_range, inertia, 'bo-')\n",
    "plt.xlabel('簇的数量 (k)')\n",
    "plt.ylabel('惯性 (Inertia)')\n",
    "plt.title('肘部法则确定最佳簇数')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "673c4d50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "K-Means 调整兰德指数 (ARI): 0.62\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfAAAAGBCAYAAACZ0uOCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzmklEQVR4nO3debxUdf3H8dcHuOwgqxdRWVRyQVwSjTHFC7n1y13Tkl+mLZRbubZh9isjy8zM1JRf/ioTJXLLDbGi64YU4JJ7abKooLgAXi6IwOf3x/eMd+7cufucmTkz7+fjMY+Z+53tc4/L+37P+Z7PMXdHREREkqVLsQsQERGR9lOAi4iIJJACXEREJIEU4CIiIgmkABcREUkgBbiIiEgCKcBF5ENm1q3YNYhI2yjARQrIzLqZ2VlmZm147UfMbMessWozW9HB797FzJ5v5WXfNbPL2/h5N5rZzh2ppYXP7G5m27Tj9YeY2WVZY9PN7KAcrz3LzHqa2TwzG2dmF5pZfzO7zswm5qN+kULSX9sinWBmVwEHApuBXsCh7v5axvNr3b1/9LjK3T8ws8nA22b2B8If0WcBu2d87AXuvhoYC/zKzM5099ui5z4ANjZTy7+iOt6PhkYDJ7n7/dHPGzKew8xeyfj5feB44ALgX2ZWC7zs7l9s4df/C/BfwIvNvSDaPpOAt7OeGgbc5e7fyBo/Bvimme3n7pujPQLvunu/HJ89CLgW2BgF9hbgN8D5wKFmtpHw/7jT3f3x6PFFwCagD/AZd/+pmX0CuCz780VKnQJcpHOGAue6e20UetmtDddmPP6rmfUjhOz5wJXAz4GPAfcC7wKXRuGNu99hZq8Du0ZBeABgwDAzWxQ9fsLdvxR9/kbgBHd/AcDM7gTeN7MpwGHAxVm17QT8AbiCEMJ/BU5z99lmdg3wQOaLzexmYD9gddb4lOhhL2C1u3884+mNwLPAS1nfvQdZf4iYWRXwA+CrwNVmdkC0rXqb2ZPR589399Oi1/4Z+C5wW/QdhwN3AftE7/stcKC7bzSznsDrhH8+A4Ea4KFo5t3X3f8T1dDD3T/8I0eklCnARTpnc9bPHzGzr9AQ5P3N7BJCyHwO+COwP2F2fRth5ncjIeB2A24HMLOtgM8AM9z971F4bgb6AU+6+/hoN3xVdkFm9hhwTvSjE2bXuWbtVcAY4DFgW2AOcIaZnZGu0czOBT7v7ksJf4yc7e5zcm0IM9sd+EnWcDdgV8KMO9PWwHNZYxcDHwFedffTMz53tbvvlfnCaE/G4cB2hFn7ZHd/1cx+DHzZ3c8xs5PdPf17dwcmEv4AGQ88D7wDnA50if4gGgG8Z2Z7uft7uX5HkVKiABfpvOvN7D1gZ2AdYTa7JXruA0JYvAcsB1YRwvFIQnh3zficIwgzSgizzdOAo8zsv939XYDMQ+ceLmSQK5j70nSXdS5fjL5nBmH2fych1K8GLnf3E8zsfqL/T7j7V83sGDN7FlgfjfeIfucq4HF3/1RUZxegyt3Pae7LLejh7u+b2ZHAfwN/J8y4nyfM9DdHL32EsMehH3As4dDDJ4AdCbPpX5vZHMIhgPpob4iZWV/C3oc1wH8If6hsiD77XcI/i6vd/RIzmwX8TOEtSaEAF+mcKuArGbvQlwM7AHPcfa2ZXe7uN5vZfoSA3AxcFb33EOBk4FVCOO1MFOjuvjI6rnsm8F9mdgEhKHsCA7IC7Uvu/o+MmowQsM0ys7HAJcD/AZdH93cBJxF21e8Y/T57kLGXwd3vjH4PzKwGOMfdj8nxFTsBN0bf8xTh/zU7E3Z1Z9bZw8wmRfV+HTgPqHf3XTNqnQLc4u5bMsZ2IhzLPgb4aVTjRcBS4LfR4Yf0HxHvm9lo4C3gG4Td9N+L3ltF2OUOYQb+ckvbTaSUaBW6SOdUEWZ/TxJ2zQL0J4Tih9z9H+4+zt33yrrVpF9CWET2RzMbGr3nfcIx8gXuvre7H0DY7Xu2ux/g7h939z0ywjs9m98GqMsay9aDsOArbQthN/MfCLvuH4xqy/zDADPb08z+mmsVvZlVpcfd/V/uPoFw3HkWcAdhdn0f8HA0thTYz93fc/e/uPtdzdT6a7LWFrj7S+7+a0LwbyD8cXMmMBj4hpm9BdRG3wswCDiXcFx/f+Bu4JTo8TZmNgDo5+7vNFODSMlRgIt0TjVhNfNewKJo7AZgaXbImdlnzexNM1sU3dKLqwBw9ycJAXdKxtvOBC6M3j8e2OLuvzezT+c49WkBIYS3uPsaYD4h8LsQZrsfilZl3531/n7AwcB0YG8zu45wXD7T0cAz3nAd4oPSv0/0+w/Oen0f4ATgqOjnOwi7+B+K6thCDmY2zcz+Ge1pqAIeNrN/mNkvM15j0ed3J8zCR0Wf+xXCCveJwNFm1tXdFxP2LKwmHGe/DHjR3dcT1h38CZiXqxaRUqVd6CKdM4owk/xQFErTofExa8Lx8Nnuflb03Ks0HMMeaGZfIiy0ejh6fgxhl/I+UdB/Hzg1ev0TwJ1mdoi7r4i+9zQzOxu4x8w+B1zv7mui3cfrmqn/M4TT4N4B9gbuIazuHkTYi/BhgJtZH2Aq8E8z6xUNP9jMLvS0lcBxhL0TvyL8wbM1cB0haHNy9+k0bMPV0d6HbPsTVuH/2sy+CRwKHERYLLhdtJu9G/Cj6PcaDiwG7gd2oWFV/u3AjwmHFEQSQzNwkQ4ysz2Ade6+ysw+SVgRvSHj+d403oXtwIkZM9atCTPjLoRFbtsDX4uOmfcDbiWE9mpCAO0A/MbM5hNmjMOBm6NjvZjZ3sB3CGE0DlhgZqPc/XZ3/xpZs/CotlnAJwkLvI4Hbib8QbLO3V+i8bH0ywinmt1MmN0fkmObdLXQrKZrtABuO8IeiYnAm4RZ+hvRy79kZiOzPqIb0M3Mcu76jz43/dw3gN+aWQ/gA3e/hhDerwL/AzwIfNzd74le/xLhEEEPYBphlf1x0dgFwAwz+1iu7xUpRZqBi3TcdsDvo8eXAk+nz+E2s70Ip2X9NuP1W4Bfu/t3otc8Ttg93B3Y5O7fy3htNeH0rhvd3S00fakjLJJ7gxCGawkrxodHs+y7gFPd/UXCceBlhFnqEjPbhRDu9RnfsYSw2O6daAX22+7+XHQ8+FYzOxEYQGg6czJh1fcEd18d/QFyHjDOzNYS9i5UEVa1j3T3181sKrA8qn87wi7s7wD/dvevRZ/5QzP7fMau9N6EPQG/NbNN0dgzGYv2ugMXmVl3wq74twh/cNxuZucRZvUnA48DPwOeM7PTCcfy7wWeBI6LFglOAc4gHAL5l5ktBi4xs2PcPXM7iZQkaziUJSJJZmYjo/O1cz03iNA8Zra7P9XBzx+Q/gMlx3NVhAmBFSL8ouPfAwh7LrZ196XR7PnFzBottHpdFh3rFikrCnAREZEE0jFwERGRBFKAi4iIJFCiFrENGTLER40aVewyimrdunX06dOn2GVUBG3rwtB2Lgxt58LI93ZevHjxW+4+NNdziQrwUaNGsWjRotZfWMZqa2upqakpdhkVQdu6MLSdC0PbuTDyvZ3NLOfCVNAudBERkURSgIuIiCSQAlxERCSBFOAiIiIJpAAXERFJIAW4iIhIAinARUREEkgBLiIikkAKcBERkQRSgIuIiCRQrAFuZtea2ZHR4xvMbL6ZXZTxfJOxQpg5E0aNgi5dwv3MmYX8dhERkc6LLcDN7EBgmLvfbWbHAV3dfX9guJmNyTUWVy2ZZs6EqVNh6VJwD/dTpyrERUQkWWIJcDOrAv4XWGJmRwM1wOzo6XnAAc2MxW7aNKivbzxWXx/GRUREkiKuq5GdAjwHXAacDZwJ3BA9txbYCegDvJY11oSZTQWmAlRXV1NbW9upwpYtOwiwHONObe2DnfrsQqirq+v0NpC20bYuDG3nwtB2LoxCbue4AnxvYIa7rzSzm4D9gV7Rc30JM/+6HGNNuPsMYAbA+PHjvbOXaRsxIuw2bzpuibjUni4JWDja1oWh7VwY2s6FUcjtHNcx8JeAHaLH44FRNOwi3xNYAizOMRa76dOhd+/GY717h3EREZGkiGsGfgPwf2b2GaCKcLz7LjMbDnwSmAA48HDWWOymTAn306aFmXjXrjBjRsO4iIhIEsQyA3f399z90+4+0d1T7r6UEOILgEnuvsbd12aPxVFLLlOmwJIlcNVVsHkzHHRQob5ZREQkPwrWyMXd33X32e6+sqWxQkqlwv1jjxXj20VERDquojux7bkn9OypABcRkeSp6ACvqoLx4xXgIiKSPBUd4BB2oz/+OLz/frErERERaTsFeAo2bgwhLiIikhQKcC1kExGRBKr4AB82LFyRTAEuIiJJUvEBDmEWrgAXEZEkUYATAvy11+DVV4tdiYiISNsowNFxcBERSR4FOKGhS69eCnAREUkOBThq6CIiIsmjAI+ooYuIiCSJAjyihi4iIpIkCvDIhOhq5NqNLiIiSaAAj6ihi4iIJIkCPIMauoiISFIowDOkG7osX17sSkRERFqmAM+ghi4iIpIUCvAMaugiIiJJoQDPoIYuIiKSFArwLKkUPPGEGrqIiEhpU4BnUUMXERFJAgV4Fi1kExGRJFCAZ6muhtGjFeAiIlLaFOA5qKGLiIiUOgV4DmroIiIipU4BnoOOg4uISKlTgOewxx5q6CIiIqVNAZ6DGrqIiEipU4A3I5UK54Jv2FDsSkRERJpSgDcjlYIPPlBDFxERKU0K8GZoIZuIiJQyBXgz1NBFRERKmQK8BemGLu7FrkRERKQxBXgLUil4/XV49dViVyIiItKYArwFOg4uIiKlSgHeAjV0ERGRUqUAb0FVFey7rwJcRERKjwK8FWroIiIipUgB3go1dBERkVKkAG/FhAnhXrvRRUSklCjAW6GGLiIiUooU4G2ghi4iIlJqFOBtkG7osnx5sSsREREJFOBtoIYuIiJSamIJcDPrZmbLzKw2uo0zs++b2UIzuzrjdU3GSpEauoiISKmJawa+B3CLu9e4ew3QAzgA2A941cwONrPx2WMx1dJpaugiIiKlxjyGlVlmdgZwDvAmsBR4Cqhz92uj4D4SWANsyBxz9+/l+KypwFSA6urqfWbNmpX3ettixowd+OMft+Peex+he/ctRakBoK6ujr59+xbt+yuJtnVhaDsXhrZzYeR7O0+aNGmxu4/P9Vy3vH1LYwuBg9x9hZldA/QCXoyeWwtUA5uAl7PGmnD3GcAMgPHjx3tNTU1MJbdszRq45Rbo23ci++9flBIAqK2tpVjboNJoWxeGtnNhaDsXRiG3c1y70P/p7iuixy8AdYQQB+gbfW+usZKlhWwiIlJK4grN35vZnmbWFTgW6EM43g2wJ7AEWJxjrGRtvTXssIMCXERESkNcu9B/ANwMGHAX8EPgYTP7BXB4dFsKXJo1VtJSKfjb30JDF7NiVyMiIpUslhm4uz/j7nu4+zh3n+buW4CDgYeBT7r7K7nG4qgln9TQRURESkVcM/Am3H09cGtrY6Us8zj4iBHFrUVERCpbSS8cKzVq6CIiIqVCAd4O3bqpoYuIiJQGBXg7pVLwxBOwYUOxKxERkUqmAG+nVAo++AAWLy52JSIiUskU4O2khi4iIlIKFODtpIYuIiJSChTgHZBKhQCP4TowIiIibaIA74BUClasgGXLil2JiIhUKgV4B6SPgy9YUNw6RESkcinAO2CPPaB3bx0HFxGR4lGAd4AauoiISLEpwDtIDV1ERKSYFOAdpIYuIiJSTArwDpowIdxrN7qIiBSDAryD1NBFRESKSQHeCWroIiIixaIA7wQ1dBERkWJRgHeCLmwiIiLFogDvBDV0ERGRYlGAd4IauoiISLEowDsp3dBl/fpiVyIiIpVEAd5JqRRs2qSGLiIiUlgK8E5KN3TRlclERKSQFOCdtPXWsOOOOg4uIiKFpQDPAzV0ERGRQlOA54EauoiISKEpwPNADV1ERKTQFOB5MG6cGrqIiEhhKcDzQA1dRESk0BTgeaKGLiIiUkgK8DxRQxcRESkkBXiepBu6aDe6iIgUggI8T9TQRURECkkBnkdq6CIiIoWiAM+jVApWroSlS4tdiYiIlDsFeB6poYuIiBSKAjyPxo2DPn10ZTIREYmfAjyP1NBFREQKRQGeZ2roIiIihaAAzzM1dBERkUJQgOeZGrqIiEghKMDzbOhQNXQREZH4KcBjoIYuIiISNwV4DNTQRURE4hZrgJtZtZk9ET2+wczmm9lFGc83GSsHaugiIiJxi3sGfjnQy8yOA7q6+/7AcDMbk2ss5loKJt3QRQEuIiJxiS3AzWwysA5YCdQAs6On5gEHNDNWFtTQRURE4tYtjg81s+7AxcAxwJ1AH+C16Om1wE7NjOX6rKnAVIDq6mpqa2vjKDnvhg8fzR/+sD1z5z5Cjx5b8va5dXV1idkGSadtXRjazoWh7VwYhdzOsQQ48C3gGndfbWYAdUCv6Lm+hJl/rrEm3H0GMANg/PjxXlNTE1PJ+fXee3DzzdC790QOPDB/n1tbW0tStkHSaVsXhrZzYWg7F0Yht3Ncu9APBs40s1pgL+BIGnaR7wksARbnGCsb6YYuurCJiIjEIZYZuLtPTD+OQvwo4GEzGw58EpgAeI6xsjF0KOy0k46Di4hIPGI/D9zda9x9LWHR2gJgkruvyTUWdy2FpoYuIiISl4I1cnH3d919truvbGmsnKihi4iIxEWd2GKkhi4iIhIXBXiMdt9dDV1ERCQeCvAYqaGLiIjEpdVV6GbWBzgW2BvoCSwH7nb3Z2OurSykUvDTn8L69dCrV+uvFxERaYsWZ+Bm9lngOmAVcAlwHqGz2vFmdp2Z9Y29woRLpWDTJli0qNiViIhIOWk2wM1sNDDU3T/n7nPdfbW7v+/uL7j7D4CfAScXrNKESjd00W50ERHJp2Z3obv7K8BVmWNmNpSG9qdDojan0gI1dBERkTi0uRObmd0AjAYGAvWETmplcwWxOKVS8MADoaFLaA0vIiLSOe1ZhT4SOBx4CTgIyN8ltspcKgVvvAFLlhS7EhERKRftCfD3gU8AXYFPE2bi0gZq6CIiIvnWngA/Efg3cC6wK3BGLBWVoXRDF12ZTERE8qXNx8DdfR1h9znAxfGUU566dYP99tMMXERE8ked2AoklYInnwwNXURERDqr1QA3syui+7+Z2bzo9jczmxd/eeVDDV1ERCSfWt2F7u7nRfeT4i+nfGU2dDnwwOLWIiIiyadd6AUyZIgauoiISP50OMDNTE1c2imVCgHuXuxKREQk6doc4Gb256yhS/NcS9lTQxcREcmXtlxOdA/CpUS3NbNTouE+wIY4CytHmQ1dRo8ubi0iIpJsbZmBW477twmNXaQd0g1ddBxcREQ6qy2r0J8CnjKznd39xgLUVLbU0EVERPKlzcfA3f07cRZSKVIpeOopqK8vdiUiIpJk7VnENifOQiqFGrqIiEg+tOc0sqfN7OjYKqkQmQ1dREREOqrNFzMB9gXONrOngXWAu/vkeMoqX0OGwJgxujKZiIh0TnuuRqZWqnmSSsHcuaGhi1nrrxcREcnWrk5sZra7mR1mZruaWd+4iip3augiIiKd1Z5FbL8Evk/owLYDcHNcRZW7zIYuIiIiHdGeGfg4dz8eWO3u9wJbxVRT2Rs7Vg1dRESkc9oT4KvM7GJgoJl9HlgZU01lTw1dRESks9oT4KcAa4DHCLPvU+MoqFKooYuIiHRGewK8H/Am8HdCkH86looqhBq6iIhIZ7QnwO8Hts34WSdAdYIauoiISGe0p5HLWne/PLZKKky6oYsCXEREOqI9Af6Imd0C3EjoxIa7PxRLVRUilYL771dDFxERab/27EL/AHgB2A+YBNTEUVAlSaXgzTfhlVeKXYmIiCRNe1qpfj/OQipRZkOXHXYobi0iIpIs7WqlKvm1++7Qt6+Og4uISPu1OgM3s38Dnj1MuBrZR2KpqkJ07RoauujKZCIi0l6tBri7jylEIZUqlYKf/CQ0dOndu9jViIhIUmgXepGpoYuIiHREswFuZiPN7JgWnh9iZp+JpaoKooYuIiLSEc0GuLsvBT5iZleZ2YfHus2st5mdAlwN6DzwTho8WA1dRESk/Vo8Bu7ul5nZSOBzZrYjYTHbeuA+d9fsO0/U0EVERNqrLYvYlgI/bO8Hm9kgYB/gCXd/qwO1VYxUCm68MTR00fngIiLSFrEsYjOzbYB7CV3b/mZmQ83sBjObb2YXZbyuyVglymzoIiIi0hZxrUIfC5zr7tOBucBkoKu77w8MN7MxZnZc9lhMtZQ8NXQREZH2as/FTNrM3f8CYGYTCbPwQcDs6Ol5wAHA3jnG/h1HPaUu3dBFAS4iIm0VS4ADmJkBJxEugmLAa9FTa4GdgD45xnJ9zlRgKkB1dTW1tbVxlVxUw4ePprZ2BHPmPEyvXluafV1dXV3ZboNSo21dGNrOhaHtXBiF3M6xBbi7O3CmmV0CnAD0ip7qS9h1X5djLNfnzABmAIwfP95ramriKrmo1q2Dm26C3r0nctBBzb+utraWct0GpUbbujC0nQtD27kwCrmd41rE9s3oXHGAAcCPCbvIAfYElgCLc4xVLDV0ERGR9mjTDNzMurn7pqwxAw529z/neMsMYLaZfQl4BrgTeMjMhgOfBCYQzil/OGusYg0eDB/5iAJcRETapq0z8L8BmFmVmd2TMX5+rhe7+7vufoi7T3T3M9x9DVADLAAmufsad1+bPdbRX6JcpFLhymSefe03ERGRLC0GuJn1M7MeQL2ZVUWv7xY97k7Ty4w2Kwr12e6+sqWxSpZKwZtvhoYuIiIiLWltF/ptwAbCMerbCKvJ98p4rLliHmU2dFFHNhERaUlru9CPBy4DnnL3o4Cj0o/d/cjYq6swY8eqoYuIiLRNawHeF/gUsMnM5gCHADcDmFkXoCre8iqLGrqIiEhbtRjg7r4CuAp4h9Db/AV3/1303BbgvNgrrDCpFDz1VDgvXEREpDnNHgM3s76E08Ec6Ad8FPioNVzvsgthIdvJMddYUVIp2LwZFi2ixYYuIiJS2VpaxFYPfJewiO1MYCXwOJBeI21Aj1irq0CZDV0U4CIi0pxmAzzaRf4ygJndBewCbO/ujxSotoqkhi4iItIWrTZyMbMLgH+4+2/d/Zas5ybFVlkFS6VCgKuhi4iINKe1Ri4LgW8At5jZSWZ2tZn91cweNbMpNNOJTTonlYJVq+A//yl2JSIiUqpam4HXEXqZTyFceGQ3d/+Eu388Gvt8zPVVpMyGLiIiIrm0FuBjo9vV6dea2clm9n/Az9397Zjrq0hjx0K/fgpwERFpXmsB/mx0uwDYEo39kXBu+OlmdnqMtVWsdEOXBQuKXYmIiJSq1gK8D2EGPiN67evA/cAvgB8B55tZ91grrFBq6CIiIi1p8WIm7r6fmX0PWAW8m2MV+rVAT2BjfCVWJjV0ERGRlrQY4GZ2EuFc8E8AtWZ2XMbTXYCV0XW9Jc8+9rFwr4YuIiKSS2u70LsSOq71AoZFr7esm8RADV1ERKQlre1Cv9nM+hCCe0/gt+7+RkEqE1IpuO++0NDF9KeSiIhkaLUTm7uvc/ffuft5Cu/CUkMXERFpTqsBLsWjhi4iItIcBXgJU0MXERFpjgK8hKUbuijARUQkmwK8xKVS8M9/qqGLiIg0pgAvcemGLgsXFrsSEREpJQrwEjdhQrjXbnQREcmkAC9xgwbBzjsrwEVEpDEFeAKkUuHKZO7FrkREREqFAjwB1NBFRESyKcATQA1dREQkmwI8AXbbTQ1dRESkMQV4Aqihi4iIZFOAJ0S6ocv69fpHJiIiCvDESDd0efHF/sUuRURESoACPCFefTXcn3vunowaBTNnFrUcEREpMgV4AsycCeeem/7JWLoUpk5ViIuIVDIFeAJMmwb19Y3H6uvDuIiIVCYFeAIsW9a+cRERKX8K8AQYMSL3+PbbF7YOEREpHQrwBJg+HXr3bjo+ejRs2VL4ekREpPgU4AkwZQrMmAEjR4KZM2IEHHssPPggnHZaOL1MREQqiwI8IaZMgSVLYN68B1m6FG6/Hb7/fbjxRjjlFNi0qdgViohIIXUrdgHScRdfDN26hdXomzfDTTeFn0VEpPzpf/cJ953vQFUVfOMbYRZ+yy3hZxERKW/ahV4GLrwQrrgCbrsNTjwRNm4sdkUiIhI3BXiZOPdcuOoquPNOOOEEeP/9YlckIiJxUoCXkbPPhmuvhbvvDqvUN2wodkUiIhKXWALczLYyszlm9mczu8PMupvZDWY238wuynhdkzHpnNNPD6ec3X8/HH00rF9f7IpERCQOcc3ApwBXuPshwErgM0BXd98fGG5mY8zsuOyxmGqpOF/+MtxwA/z5z3DEEU37qIuISPKZu8f7BWa3Av2BK939PjM7AegH7A3cnznm7r/J8f6pwFSA6urqfWbNmhVrvaWurq6Ovn37tum1DzxQzU9+sgvjxq3h0kufplcvdXxpj/Zsa+k4befC0HYujHxv50mTJi129/G5nov1NDIzSwEDgSXAa9HwWmAnoE+OsSbcfQYwA2D8+PFeU1MTX8EJUFtbS1u3QU0NjBsH//3fA/jRjw7kvvugX79Yyysr7dnW0nHazoWh7VwYhdzOsS1iM7NBwC+BLwB1QK/oqb7R9+Yakzz77Gdh1ix47DE47DBYs6bYFYmISD7EtYitOzAb+La7LwUWAwdET+9JmJHnGpMYfPrTMHs2LFwIhx4Kq1cXuyIREemsuGa9XwT2AaaZWS1gwOfM7ArgROBe4M4cYxKT446DW2+FJ56Agw+Gd94pdkUiItIZsQS4u//K3Qe6e010+x1QAywAJrn7Gndfmz0WRy3S4Oij4Y474Omn4ROfgLffLnZFIiLSUQU77uzu77r7bHdf2dKYxOtTn4I//Qmefx4mT4ZVq4pdkYiIdIQWjlWgww+He+6Bf/0LJk2CN94odkUiItJeCvAKdfDBcO+98Mor4XSzFSuKXZGIiLSHAryCTZ4Mc+bA8uUhxF97rdW3iIhIiVCAV7iJE2HuXHj9dTjooBDmIiJS+hTgwsc/Hvqmr1oVQnzp0mJXJCIirVGACwATJsBf/gLvvhtC/JVXil2RiIi0RAEuH9p3X/jrX2Ht2hDiL79c7IpERKQ5CnBp5KMfhXnzwiVIDzoonGomIiKlRwEuTey1F/ztb7BxY1id/sILxa5IRESyKcAlp3HjoLYWtmwJIf7ss8WuSEREMinApVm77RZCvEuX0LHt6aeLXZGIiKQpwKVFu+wCDz4I3buHEH/yyWJXJCIioACXNhgzJoR4796he9vjjxe7IhERUYBLm+y4Ywjx/v3DpUgXLix2RSIilU0BLm02enQI8UGDwsVQFiwodkUiIpVLAS7tMnJkWNi29dZw6KHw6KPFrkhEpDIpwKXdtt8+hPg228Bhh8FDDxW7IhGRyqMAlw7ZdtsQ4iNGwCc/GRq/iIhI4SjApcO22SYE9+jR8KlPhYuhiIhIYSjApVOqq0OIjxkDRxwB999f7IpERCqDAlw6bejQcAGUXXeFo4+Ge+8tdkUiIuVPAS55MXhwuBTpuHFw7LFw113FrkhEpLwpwCVvBg0Kx8H33huOPx5uv73YFYmIlC8FuOTVgAHwwAOw775wwglh93qXLjBqFMycWezqRETKhwJc8m6rreCLXwQzeOstcIelS2HqVIW4iEi+KMAlFpdcEq4lnqm+Hi64IAS6iIh0jgJcYrFsWe7xlSthu+3g9NNhzhx4//3C1iUiUi4U4BKLESNyjw8eDBMmwO9/D//1XzBkSDhW/vvfw9tvF7ZGEZEkU4BLLKZPD9cPz9S7N/ziF3DbbeHY+L33wpQpMH8+nHJKaApTUwNXXAEvvVSUskVEEkMBLrGYMgVmzAhXLzML9zNmhHGAnj3DDPy66+DVV+Ef/4BvfxveeQfOPz90dhs7NowtWND0eLqISKVTgEtspkyBJUtC+C5Z0hDe2bp0CaedXXIJ/POf8J//wJVXwrBh8NOfQioFw4fDl78Md98N69cX8JcQESlRCnApOaNHw9e/Hjq7rVoVTj2rqYHZs+Goo8Jx9GOOgd/8Bt58s9jViogUR7diFyDSkoED4eSTw23jRnjwQfjTn0Kr1j/9KeyeT6VCD/ajjoJddil2xSIihaEZuCRG9+5wyCFw9dWhMcwTT8D3vgcbNsA3vxkuprLzznDhhfDII7B5c7ErFhGJjwJcEskM9torBPjixeG882uuCS1bf/ELOPDAcAz9tNPgjjtg3bpiVywikl8KcCkL228PZ5wBc+eGU9Rmz4bDDoM774TjjgvHzY84IqyEX7Gi2NWKiHSeAlzKTv/+8OlPw003hUVu8+aFzm/PPQdf+UpY0f6xj8GPfgTPPNO0tevMmWEmP3nyQboIi4iULAW4lLWqKpg0CX7+c3j5ZXj66dBkBmDatHD98p12gnPPhdra0BFu6tRwjN3ddBEWESlZCnCpGGaw++7wne/A3/8Or78O118fFr/96lch6E89NVx0JVN9fQh7EZFSogCXirXNNmF2fc89oQ/77bc33/Ft2TKtaheR0qIAFwH69IFjjw0tX3Nxh6FD4cQT4YYbQvtXEZFiUoCLZMh1EZZeveCss0L3t0cfhS99Kax6HzsWzjsvrHxXe1cRKTR1YhPJkO7XPm0aLFvmjBhhTJ/eMO4Ozz4bQnvuXLj22rBArmdPmDgxnLp22GGw227hmLuISFw0AxfJkr4Iy7x5Dza5CEt6Idz558MDD4Srp82ZA1/9KixfHsZ33z1cD/2LXwzno7/zTrF+ExEpZ7EGuJlVm9nD0eMqM7vHzOab2ReaGxNJkt694fDDwyz8uefC6Wf/+78wYUJYFHfSSeHY+YQJoWvc/PmwaVOxqxaRchBbgJvZQOB3QJ9o6GxgkbvvDxxhZv2aGRNJrBEjwjHyP/4xXElt/nz47nfDzP2HP4SPfxyGDIETTghBv2xZsSsWkaSKcwa+GTgJWBv9XAPMjh7PB8Y3MyZSFrp1C1dK+5//gcceC4E+e3YI77//PZzCNnJkOA/9nHPCrvjsc9BFRJpjnt1HMt9fYFbr7jVm9lfgOHdfY2ZTCcH+5ewxd5+V9f6pwFSA6urqfWbNmpX9FRWlrq6Ovn37FruMihDntnaHpUt7s3DhIBYuHMRTT23Fxo1dqarawh57rGbffd9l/Ph32GGHdWW/GE7/TheGtnNh5Hs7T5o0abG755zcFnIVeh3QC1gD9I1+zjXWiLvPAGYAjB8/3mtqagpUbmmqra2l0rdBoRRiW596arhfvx4efhjmzu3C3LmDuO66QcCObLMNHHpoWNl+yCFh93u50b/ThaHtXBiF3M6FXIW+GDggerwnsKSZMZGK06tXCOqf/SxcYGX58tAw5sAD4a674OSTYeutYd994aKLQth/8EHD+9MXYOnSBV2ARaRCFHIG/jvgPjM7ENgN+DvwWo4xkYq33XbwhS+E2+bNsGhRw7nnl14aGs707w+TJ8PAgTBrVkMzmfQFWKDxKXAiUl5in4G7e010vxQ4BHgUONjdN+cai7sekaTp2jVc/vTii0MnuLffhltvDaeoPf44/OY3TTvB1deHK6w98wysW1ecukUkXgXtxObur9Ow6rzZMRFp3oABcPzx4eYeAj7XWtRVq8LlUiGciz56dNi9Pnp049uIEdCjRyF/AxHJB7VSFUkwsxDAS5c2fW7YsNBg5pVXwm3JkjBjv+OOxsfPzWD48KbBnr5tu234I0FESosCXCThpk8Px7wzzyHv3Rsuvxw+85mmr9+8OVwLPTPY049ra+GmmxrP6Lt1C38kZAd7ejZfXa2+7yLFoAAXSbjGF2AJYZt5AZZsXbuGq6ltv324AEu2jRvD52SH+yuvhBXxb77Z+PW9ejXeNZ+9m37gwNx1zJyZrvmgVmsWkaYU4CJlYMqU/IVf9+6w007hlsu6dWGXfWawp2+PPgpr1jR+/VZbNQ33pUvhmmtgwwYA08p5kQ5QgItIu/TpEy6XuttuuZ9fvTp3uL/4Itx/f/PXTq+vD1d1W7Ik7B3YbruGW/Y12kVEAS4ieTZgAOy9d7hlcw+74LfZJvfK+bq60Kgm26BBjUM9/ThzTCEvlUYBLiIFYxYWvTW3cn7kSHj+eXjttdCN7tVXwy39ePnycCGYt95q+t5Bg5qGevZjhbyUEwW4iBRccyvnp08Pi+JaOgYPYTf8a681DvfMx82F/MCBrc/k+/Rp+r60hoV3rS8WFImbAlxECq7xynlnxAhrVxi2JeQ3bGg8k88O+oULQ7ObbAMH5p69v/giXHlleuGdWtZK8SnARaQo0ivna2sfjOXqTT17wo47hltz0iGfvZs+HfTNhXxafX0I8cWLw3H97NuAATpHXuKjABeRitWekB8zJvfCu/p6uP76xocD0nr0CB3xcoV7+jZsWLjSnLrdSXspwEVEWpAO+ZYW3r3yCrz3HqxY0XBbubLxzy++GDrdvftu08/o0iWEeK5wz/65Z8/21a+GOeVLAS4i0gYtLbwzC5d37d8fdt655c/ZsAHeeKNxuGcH/xNPhNds2dL0/QMH5g737KDv3x9uvjmzZjXMKTcKcBGRNmhvy9rm9OwZZu0jR7b8us2bw/H3lmb1jz4a7t9/v+n7e/UKF63ZtKnxePpSszvvHE7pq64O3fckeRTgIiJtlM+Wta3p2jXMpIcNy90UJ809dL/LDvcVK+CKK3K/Z9Uq2Hffhp8HDgzfU13d8J3px5ljQ4eGi9tIadA/ChGRBDMLATxwIOy6a+Pnbrut+UvNXn992E2/cmXD/cqVsGhRuK+ry/1dQ4bkDvfsscGDO74wT+fbt40CXESkTLV0qdmjjmr5vevWhWDPDPfswH/ppXCfPjc+U3phXnOz+cyxQYMaTrebObNxzTpu3zwFuIhImepMw5w+fWCHHcKtJe5hBX5LQb9yJTz3XLj/4IOmn1FV1RD2zz3X9II39fVw4YUweXLYA1BV1bbfv9wpwEVEyljcDXMyV+CPGdPyazOP1zcX+IsX537vihUwfHh4PHBgOB6/9dbhPvNx9v2QIeV73L5Mfy0RESk1LR2vTxs1Kvdx+yFD4Ac/CFezW7Wq4f5f/4JHHoG338592h2EXfS5wj3X2ODBHQv8YpxvrwAXEZGS0dxx+yuvbDkQN2+Gd95pHO6Zj9P3zz8PDz0UAj9XZz2z5gM/V/APHgyzZhXnfHsFuIiIlIyOnm/ftWtDuO62W+vfs3lzCPHWAv/ZZ0MHvXfeaT7wzZrO/uvrw++gABcRkYpRiPPtu3YNs+itt4axY1t//aZNzQf+JZfkfs+yZfmtOZsCXEREpBXdujV0rst24425j9uPGBFvTV3i/XgREZHyNn16OE6fKd0nP04KcBERkU6YMgVmzAj97c2ckSPDz3EfBlCAi4iIdNKUKbBkCcyb9yBLlhSma5wCXEREJIEU4CIiIgmkABcREUkgBbiIiEgCKcBFREQSSAEuIiKSQApwERGRBFKAi4iIJJACXEREJIEU4CIiIglknusCpyXKzFYBOa75UlGGAG8Vu4gKoW1dGNrOhaHtXBj53s4j3X1oricSFeACZrbI3ccXu45KoG1dGNrOhaHtXBiF3M7ahS4iIpJACnAREZEEUoAnz4xiF1BBtK0LQ9u5MLSdC6Ng21nHwEVERBJIM3AREZEEUoAnhJltZWZzzOzPZnaHmXUvdk3lzMyqzeyJYtdRCczsWjM7sth1lCszG2hm95nZw2Z2XbHrkfxRgCfHFOAKdz8EWAkcXuR6yt3lQK9iF1HuzOxAYJi7313sWsrY54Cb3P1AoJ+Z6VSyPIv+4H84elxlZveY2Xwz+0Kc36sATwh3v9bd/xz9OBR4s5j1lDMzmwysI/yhJDExsyrgf4ElZnZ0sespY28DO5vZAGB7YFlxyykvZjYQ+B3QJxo6G1jk7vsDR5hZv7i+WwGeMGaWAga6+4Ji11KOokMTFwPfKnYtFeAU4DngMmA/Mzu7yPWUq0eAMcDXgBeAd4tbTtnZDJwErI1+rgFmR4/nA7Ht8VCAJ4iZDQJ+CcS6W6bCfQu4xt1XF7uQCrA3MMPdVwI3AZOKXE+5+hHwVXf/ASHATytyPWXF3de6+5qMoT7Aa9HjtUB1XN+tAE+IaGY4G/i2u1d6P/g4HQycaWa1wF5m9usi11POXgJ2iB6PR9c5iEtvYJyZdQU+Bujc4XjV0bB+pi8x5qwCPDm+COwDTDOzWjM7qdgFlSN3n+juNe5eAzzp7l8qdk1l7AZgkpk9BJxBWDgo+XcpobnIGmAQcEtxyyl7i4EDosd7Akvi+iI1chEREekkM6t19xozGwncB/wF2B+Y4O6bY/lOBbiIiEj+mNlwwix8btbx8fx+jwJcREQkeXQMXEREJIEU4CIiIgmkABdJIDM7Peqslf75bDNLxH/PZjaqmfEdco2LSG6J+A9eRBqY2QGEU4Nmm9lcM7sQmAbcb2b3R8+nXzvdzEZHj7ub2W05Pu8HZlYTvfZbZtYv+tyuWa/b1sxWRqcxZt5WmNl2baz9m8BHm3n6SDM7uW1bQUQU4CIJYmZDgR8COwLPA9OBI4HRhEYo57v7Ixlv2YeGBimHAPVmtkt0625mfQndovYHtgZ2AkYB69x9s5l1yZjZb2yhtFZPk4lm3tu7++1mdqqZnZr5vLv/AvhUnL2jRcpJt2IXICJt5+6rzOwQ4MfAN919g5ktJrTHvB6oMrPewAbCRSyeAh43s3uAvQhh/S1gP+A44D1gMHAW8CShd/OZwE5Rg5WdgGOAfxBC+mZC//JMu9JyuKd9Dri6ldfcFH3f79vweSIVTQEukiBRB77TgD2APczsLmAcofdyDeG/6RXuXm9mj7v7J8yshtDpbAVhhr7WzK4hhO5mwoz7Z8AuwLDos6cRWp1+xd3/YWafB04mdPManl0WMNPMfuHuc1oof0d3fyHr9xlL6O9/tLu/BywAvosCXKRV2oUukiDu/gfgHMJM9UjCDLuK0Et8O2AkYeYNsGfU0/1Kwqz5x9H7AHoQZundgO9Hn/Ez4OeEoN8HGAH8J/re30Xf2xNYRAjytdHjXsC5rYR3LtsAM4GTo/AGWI+uwy7SJpqBiyTPMMJFKR4n7PpeCGwh9Lhe7u6botc96e4HRzPwGnd/2cw2mdkehJDcQNj9/UPC5Sb3JOxmHw3cHn1GZih3IQR7f8LxcgM+Er230YK3Zqw3s77uXhf9fBbwBOGPjvS110cDy9u0FUQqnAJcJHkOAC4AvkoI8t0IwXoA8J6ZXe/utzfz3rOANwhXqHrP3R81s9nABEJYP+vuH5jZ48DRwA8y3vse8H+EGf7ehEBfDAyh4VrILbkPOB74XfTzJdHYr4FDo7ETafjjQURaoAAXSZDo3O/DCFfuGgp8HXiGcPx7B+CcjMvN7h3tQh8A3Ang7q9HnzPE3T+IXncdsA64CFganXY2lnCM/KOE3eQAk6Pv2UzDDHx7QpAvApa1Uv49wB/MLD2r3+Duy8zsBTM7inCt6m3d/el2bBKRiqVe6CIJYmafJRwnPpiw23op4dj3uYQwvSa6zQHmuPuhZpYCDnT3y6LFaBcBC9z9c2Y2EPgV4Vj3jwiz+csIM/w3gFsJi9e2An4afTc0BPgb0c+9gG+5+8JW6t8OmOjuN+d47qvAze7eltm8SMVTgIskmJlVZcyk2/L6gUA3d1+VMdYtfdzczAzokr78oZmZ638SIiVJAS4iIpJAOo1MREQkgRTgIiIiCaQAFxERSSAFuIiISAIpwEVERBLo/wHJXJMl38yeIQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAGACAYAAABiAiEGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAABwIUlEQVR4nO3dd3hUVfrA8e+ZnkkhAQIiKKAIgopKsSPBBvYuurrK6q5iXbGw1nUtuyq6yq6oqD8V21p3batiWQ12EBAFRVR6LymkTJ97fn/cCclk7oSESWYmyft5njyQc8+ceecmmXfuvee+R2mtEUIIIUR2smU6ACGEEEIkJ4laCCGEyGKSqIUQQogsJolaCCGEyGKSqIUQQogsJolaCNGmlFIq0zEI0Z5JohZCxFFKuRp9b1NKuZVSziYes5dS6nex/5+plHoi9v8TgUcs+v9NKTWqUdt5SqnHWuVFCNGBSKIWohUppf6ilLon9v+9lFLlSqlBTfSfoZSqVqZipZRWSv0lbQFbe1optVUp9blS6nNgK3AP8Hms7Qel1IuNHuMD7lJKHQaEgaBSygtMAd5q2FEplQ9cBKxsNEYo9pVAKbVYKfVN7Pl/UUqtqotPKbU55VcsRBZzZDoAITqi2NHnc8DNWusl2+meB+wK9G/zwJpBa32uUmodsCjW1A24D3gIM2FPBJ6o66+UcmMm3T8ChwE/xTYdAHwMzFRKubXWwVj7pcAMoFYptR8wHTCAIqBAKbU/4AH+pbV+IPaYMHCm1nqFUur3QB+t9V9iz7+2VXeAEFlGErUQbeM2YJ3W+tFm9F0K7IWZqJe2aVTN5wX2jP3fobVep5S6FngNKASuaND3TcwkGwYKgH2A9cChQC3wOeBWSh0FFANXASOBa4FdtdYHASilzgAO01pfnSSmV5VSQaBng/GE6PAkUQvR+g4ADgcGNrP/IuoTdd1RLLFrvjcCOcAdWuu66763A78HophH7M8ppSYAR8ceOg4oBc7QWutY/z8ACrhTa51wzdjCAq11iVKqJ/CZUupAzORtB/4DzFJKnaC13qS1HheLaxDmkfL0WGwbgFHA1VrrxbE+Z8e2lcbi2V8pdRwwAhgM9FVK3QJEtdZ3N4jHCVwJrAXOBHoB/4xt+7IZr0eIdksStRCtbwywAjgNuB9AKfUmcGCjfk/F/l2Mmah3Bb6J9d8buAbzyNMBfK+UegtwYya/gUAXYD7mKXaA0zGT2CXAr8B+SqmVwJ8wj0IdwONYTO6qo5SyA68AByqlqjCPiL3AwZintk/HPOrvhXlkvSmWxC8E9gAujr2WI7XWdymlSoA3lVKPa63v11pPB6YrpV4H7tZa1yqlfgLKgHcbhGJvFNqDsRjATOpdgDNi3/812esRoiOQRC1E63sVeBR4USn1sNbar7U+2aqjUmoGZlIdhXnU6I9tGgPsBtRd384BBmmtP1VKXY152ngMZgKuM1dr/XZs3CWYyWwr8AvwD2AmcEFTgWuto0qpDzGPdusme12Nee35u9j/5wAXaq3Dse1e4DWt9Yex5y7EvO6O1rpUKXUAZmJHKWUDbo095mCl1HBgITC1USjfAbOVUgMxJ6PVAnUrCHUHXJgfFGLDqt8Dh2itq5t6fUK0R5KohWh9y7TWnyillmKecv7ndvpHgXxgTYM2BTyrtb4Uts2UDsZuaZqBeQ38Gcwj9zoNr29r2JZ4RwJHAccDdyql9tJaW86ujj1meiyhHoh5FP0OcAdwHDAW8wj9B+CT2EMewpwYdlvs+35Aj9iM8brXkhe7xr0SGI955sCOeUagAFiktZ4Qe60DgP9r8JqGY84q3wn4H/Cv2D4bC5yH+UGkC1CT7DUJ0Z5Johai7fwVeFwp9ViDGc/JLAFWNfj+Y+AapdROmEeT32GeSj8Q84j2BcxT3A0lrFkbOyJ9GjNRf4p5jbcb5mSvBEqpYuB64AjgJuBhzMliUczr519gHrkGtj2p1ns3eHz3WJ/nMSfT3WLxNENifbtgnu7Pt4olNnYU80PA2FgskzDPIvTBnJT2PnAD8KqWNXtFByX3UQvRRrTW7wIbMa/fbs9i6m9rQmu9CLgT+Ar4EXhYa70Ac9b13pgJdwhQE0vGyWL4GfgMWA78DEzTWlsm6ZiemNeL78M8Xf4xUIH5QWEk5lHwu0qpSUqp3nUPUkrZY8VNZgHXYU52y1VKva+UOqRBv1Nj90OvA77HvKYNcIJSaq5Sai7weoP+3ZVSX2Hej31W7NS+DbBrrb/GPEswEVivlOrVxOsSot1S8iFUCNGQUupy4CTgMq310tis7FO01hfHth+Aecr5Zsyj/aeB0ZgfCO7QWv/SYKxjgL9h3r51COZ1+KHA11rr8lif4zHvkZ4Q+34AMENrfVjs+3HAB1pro0F8u2qt/9TgefbUWm/7oCNERyKJWgiREqXUEGCF1trXRJ9+WusVSba5AY/WemsbhShEuyaJWgghhMhico1aCCGEyGKSqIUQQogsJolaCCGEyGJZeR919+7ddb9+/ZJur62tJTc3N30BCdnnGSL7Pf1kn6ef7HPTvHnztmitixu3Z2Wi7tevH3Pnzk26vbS0lJKSkvQFJGSfZ4js9/STfZ5+ss9Nsdr8CeTUtxBCCJHFJFELIYQQWUwStRBCCJHFsvIatRBCiI4pHA6zZs0aAoFt67rQpUsXFi9enMGo0svj8dCnTx+cTmez+kuiFkIIkTZr1qwhPz+ffv36oZQCoLq6mvz8pIuodShaa8rKylizZg39+/dv1mPk1LcQQoi0CQQCdOvWbVuSTsowIFmJa63N7e2QUopu3brFnVHYHknUQggh0mq7SdrngwkT4IorIBSK3xYKme0TJpj9dtCjjz5KZWXltu8feughjDQl/+2+/kYkUQshhMgePh9MnAjz5kFpKVx9dX2yDoXM70tLze0TJ+5Qsv7888+58cYbOeussxg7diz33Xcff/3rXxk3bhzjxo3j888/j+t/55138sQTT2x33Msvv5zy8vIWx7M9kqiFaAPhaJStgQCyOp0QLdAwSRcXm1+zZpnJuabG/HfWrPptO5CsN2/ezC233MLSpUsZPHgwN998M2+//TbLly+nb9++/P3vf+ewww6Le4zL5cLlcm137GHDhnHllVe28EVvn0wmE6IVRQyDKV98yvMLvyNqGBTl5HDLqDGcMHBQpkMTIrsZRnySrjs9XJesx42DiorEbXXJesYMsG3/2LO4uJgPP/yQG264gXvvvRePx8Pw4cN5+umnueSSSwiHw/h8PoYPH07v3r0BWLVqFS6Xi+eee45AIEBeXh4zZ86MG9fv93P++edTXl5ONBrFbre32q6RI2ohWtFdn37C8wu/IxCJEDYMNtXW8qePZvL5KsvKgEKIOkqB1cxvpcyEXFMTn6Qbys+3brfw8ssvc+KJJ/Liiy9y4okn8tBDD7Fw4UJ8Ph+lpaXMnDmT6upqnE4nH330ER999BEXX3wxN9xwAx999BHPP/88Dkf9Me5dd93F2rVrOfHEE/nll1+4/vrrsdvtTJkyhYULF+7o3ogjiVqIVuILh3n5h0UEIpG4dn8kwkNzvspQVEK0E0rBgw/C6NGweXP8jG+loKgoPhlrbfYbPdp8XDMT9fjx45k6dSrnnXceb7/9Nvvuuy/hcJi5c+eyZs0aVq5cSbdu3bA14+gcYPr06XTv3h2PxxP3mCOOOIIJEyYQajwZbgfIqW8hWkmZz4c9yZvFqq1b0xyNEO2QywVTp8Zfi7b6m2qYpKdONR/XAhs2bGD27NkMGzaMadOmMXLkSGw2G+eccw677LILDoeDSCTCUUcdBdSf+p4xYwaBQICCggIAVq5cyc4774zb7U54jhEjRjBy5Eief/55LrzwwhbuiHhpTdRKqa7AcOBbrfWWdD63EG2tZ16e5XuKAvbu0TPt8QjRLrlcMGWKeU26stI8km6srn3KlBYnaTBnfd9///1Mnz6d2bNn8+OPPzJv3jw+//xz8vPzueSSS3jqqac44IADALj//vvZaaedOO+88wgEAvz8888AfPzxxxx88MGWz+H3+5k6dSoej6fF8TWWtlPfSqlewDvAAcAnSqmENTeFaM9cdjtXHXAwOY74z78eh4NJBx2SoaiEaGdCIZg82Zw4Vlho3aew0Nw+eXLifdbbUVlZyfvvv88+++zD5s2bufLKK7n00ks577zz6NmzJ48//jinnXbatiQNYBjGtjs4PB4PQ4cOBeB3v/sd995777Z+0Wh02/9HjhwZ930q0nlEvRcwSWv9tVKqCBgGvJ/G5xeizf1h+Ei6e708PHc2m2pr2adHT/506OEMKe6R6dCEyH5190k3ddob6ieY1d261YLT3++99x7XXnst1113Hb1792batGmsWbOGBx98kNWrVzNx4kQuv/xyTjjhhG2PqampSXqtue6Ief/99+e4446jqKiIUCjE7rvvTm5ubgtefHIq3fd5KqUOB+4CTtBaV1n1GTFihJ47d27SMWSR8fSTfZ4Zst/TT/Z521q8eDGDBw+Oa6uuriY/L8+sOFZampiktTZPdxcWWk8oKymBadOaPaGsoXA43OzFMVqT1X5QSs3TWo9o3Dfd16gVMB4IA9FG2y4GLgbo2bMnpaWlScepqalpcrtofbLPM0P2e/rJPm9bXbp0obq6Oq4tGo1SXVWFu7wcu2Ggo9H6pKs1assWdGEhauNGdPfu8dsMg2h5OcGqqmbdR22lJXW3W0sgEGj271naj6gBlFJ3Aou01i9bbZcj6uwj+zwzZL+nn+zztrV48WL23HPPuHrX21bPalyZDOpnd0+ZYl6TrjstXrdt+HCYPh283gy8mh2jteann35q9hF1OieT/UkpdX7s20KgMl3PLYQQIjt4PB7Kysqsy+t6vWbSHT7cTMINb8HKyzP/rbvPuh0n6bKyshbNBk/nqe/HgVeUUr8HFgEfpPG5hRBCZIE+ffqwZs0aNm/evK0tEAjEJS519dXsdPvtGLm5bLzkEli6tH6ASy6hZ2UlttpaNlx9NXpl+6v65/F46NOnT7P7py1Ra60rgKPT9XxCCCGyj9PppH///nFtpaWl7L///vEdX38dlKKr1QSxF14ArSncwWvS7Y1UJhNCCJF9mkrCSu3QDO/2qnN8HBFCCCHaKUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTEqKi09pYU8PstavJd7s5dJe+uOz2TIckhBAJJFGLTukfX3/Jo/Pm4LTZUErhsNl47pQz2KtHz0yHJoQQceTUt+h0vly9isfnf0MoGqU2HKYmFKIyEOB3b/2HqGFkOjwhhIgjiVp0Oi8u+g5/JJLQHghHmLd+XQYiEkKI5CRRi06nJhSy3qDAHw6nNxghhNgOSdSi0zlh4J7kOJwJ7RHDYMTOvTMQkRBCJCeJWnQ6Jw3ck7179MDrNJO1TSk8Dgd3lBxJrsuV4eiEECKezPoWnY7TbueF087ig6W/8OGypRR5PIzfeyiDunXPdGhCCJFAErXolBw2G8ftMYjj9hiU6VCEEKJJcupbCCGEyGKSqIUQQogsJolaCCGEyGKSqEVGaK3RWmc6DCGEyHoymUyk1caaGm4t/YhPli9DKcUR/XbjzjFHUZybm+nQhBAiK0miFmkTjEQ4/ZV/sbG2hqjWoDX/W76UHzZv4uPzL8Qpq1cJIUQCOfUt0ubDZb+yNRgwk3RMVGsqA34+Wr40g5EJIUT2kkQt0mZpRTm1FrW0/eEIyyrKMxARYBiQ7Fq51uZ2IYTIIEnUIm326NqdXGdije0cp4OBXTNQFczngwkT4IoroPFCHaGQ2T5hgtlPCCEyRBK1SJujd9udrjleHLb6XzuHzUZ3by5j+u+W3mB8Ppg4EebNg9JSuPrq+mQdCpnfl5aa2ydOlGQthMgYSdQibZx2O/8+6zccN2AgbrsDj8PB8XsM4t9nnROXvNtcwyRdXGx+zZplJueaGvPfWbPqt0myFkJkkMz6FmnV3etl6rjjMxeAYcQnaaXM9rpkPW4cVFQkbqtL1jNmQDo/VAghOj15xxGdi1KQn2/dXlxsHlE3TNIN5edbtwshRBuSRC06F6XgwQdh9GjYvDl+xrdSUFQUn4y1NvuNHm0+ThK1ECLNJFGLzsflgqlTrZN1Qw2T9NSp5uOEECLNJFGLzsnlgilTzCPoykrrPpWV5vYpUyRJCyEyRhK16JxCIZg82Zw4Vlho3aew0Nw+eXLifdatpCoY4Il53/D7t17nrk8/YWWyDw1CiE5LZn2LzqfuPum6W7CSXXeum2BWd+tWK5/+3lxby4kvPUdVMEggEsFhs/Hiou956qTTOLDPLq32PEKI9k2OqEXnojVMmmSdpLU2j6AbTzCrS9aTJiW/nr0Dps7+knK/n0AkAkDEMPBHIlz/0UxZAlQIsY0katG5aA3V1dbtmzdDXl7yCWbV1a2aqP+3bCkRi1rim2tr2Vhb02rPI4Ro3yRRi87FZoPp02H48PqE3HB298yZ8bPB67YNH24+rhWLneQmOY2uNXgtaqILITonSdSi8/F645N1w1uw8vLib91qmKS93lYN4/x99yfHET9NxGGzcWCfXShwe1r1uYQQ7ZckatE5NUzWJSXxE8Xq7rMuKWmzJA1w3j77cuyAgbjtdvJcLrwOJ3t07cYDxxzb6s8lhGi/ZNa36Ly8XrN2t1KJM79dLpg2zTwP3Ua1ve02G/cfcyxXH3QIizZtYuf8fPbp0RMl1c+EEA1IohadW1NJ2CqBt4E+BV3oU9ClzZ9HCNE+pS1RK6W6AC/FnrMGGK+1bpsqEkIIIUQHkc5r1OcCD2itjwY2AOPS+NxCCCFEu5S2I2qt9SMNvi0GNqXruYUQQoj2Ku3XqJVSBwNFWuuv0/3couObs2YNn69ZyYheO3N43/6ZDkcIIVKm0lmqUCnVFfgAOF1rvbLRtouBiwF69uw5/KWXXko6Tk1NDXl5eW0Zqmgk2/e5oTU/l5URMaLb2uw2GwO7dsPeRrO20yHb93tHJPs8/WSfm8aMGTNPaz2icXvaErVSygW8C9yrtf6wqb4jRozQc+fOTbq9tLSUkpKS1g1QNCnb9/mZr77IvPXrEtp3Kyzio/MvzEBErSPb93tHJPs8/WSfm5RSlok6nYcaFwHDgZuVUqVKqfFpfG7Rwc23SNIAyyorLOtpCyFEe5HOyWSPAo+m6/lE59LUeaFQJIKjFZenFEKIdGq/F++EaKDIY10bO8fhwCtJWgjRjkmiFh3CA8ccZ9l+1xFHpzkSIYRoXZKoRYcwul9//nvOeQzbqRdd3G72Lu7Bq2eczal7Dsl0aEIIkRKp9S06jCHFPXntrN9kOgwhhGhVckQthBBCZDFJ1EIIIUQWk0QthBBCZDFJ1EIIIUQWk8lkImWPfPM1D379JdFYOdrdC4t459wLcNntGY4s/bTWvLjoex6ZO5syn48hxT24adRohvfqnenQhOg01vy8junXPsOCTxbhyfVw4sRjOPeW03E4U0t5WmveeeIjXvzbf6jctJXd9+vHJfdfwF6HDGqlyK3JEbVIyUuLvuf+r77YlqQBllZWcPCT0zMYVeY8Mnc2f/2slHXV1QSjUb7dsJ7fvv4a32/ckOnQhOgUytZXcOVBNzHn3W8J+kJs3VzFq/e/xd3n/TPlsf/1t//w2DXPsGnVFkKBMIu//oU/HXMHS+YubYXIk5NELVJy16ellu0VgQA/btqY3mAyLBiJ8Og3c/BHIgntU7/+MkNRCdG5vDntPYL+IA0XnAr6Q3z99lzWL9/x96RQMMxL97xOwBeMb/eHePa2l3d43OaQRC1S4ouEk257f2nbfsrMNhtra0Altmvgxy2b0h6PEJ3RT3N+JRyMJLQ73U5W/rBmh8ctW1tu2a41LP1uxQ6P2xySqEVKPE1chx61a980RpJ5xd5cjCTLxu5W2DXN0QjRgRiGmRGtaG1uj9lt6K44nInvS5FQhN577LTDIRTtVIg2rGPoM3DnHR63OSRRi5RcdeDBlu1eh4MRvTvXBKocp5Pz9tmXHEf8hBWPw8Efk+wnIcR2+HwwYQJccQWEQvHbQiGzfcIEsx9wypXH4XA747o53U6GHDKIXQbt+HuSx+vmxMvG4va649rdOS5+e9uZOzxuc0iiFimZOOJAfrP30Li2rp4cPvvdxRmKKLP+dOjh/H7YCPKcLmxKsUtBF/457ngO7LNLpkMTov3x+WDiRJg3D0pL4eqr65N1KGR+X1pqbp84EXw+durXg/s//gsDhvVH2RROt5Mjzx3F7W9MTjmc399zLmdeeyLe/BxsNsVO/Xtw04tXs+/ovVIeuylye5ZI2V1HHM1dRxxNma+WfLenU96WVcduszHpoEO5+sBDCEWjuB3yJybEDmmYpIuLzbZZs8zkPGUKTJ5sfl+3rS5ZT5/OoBG78+jcKYRDYewOOzZb6xyT2u12Lrh9POf/5SzCoQiuRkfubUWOqEWr6ebN7dRJuiGllCRpIXaUYcQnaaXMr+JiMzmPG1efpBtuq0vWsWvWTpez1ZJ0Q0qptCVpkEQthBAi2ygF+fnW7cXFUFNTn6Qby8+3bm/HJFELIYTILkrBgw/C6NGweXP8jG+loKgoPhlrbfYbPdp8nCRqIYQQoo25XDB1qnWybqhhkp461XxcByMX0UTKQtEo7y/9hc9XrWSnvDzOGrIPvQsKWmXsNVVbeeWHRWysrWHUrn0Zu/seOJNcB68OBnnjpx9ZuGkjA7t154whe1HoyWmVOIQQGeBymRPHxo2DykrzSLqxuvYpUzpkkgZJ1CJF/nCYs157ieWVFfjCYZw2O0/Mn8tjx5/MqL79Uhq7dMVyLnv3LaKGQdgweOeXJTwxfy4vnzEejyN+Ise66ipOefkFakMh/JEIHruDh7/5mn+f9Rt2K5JiI0K0S6GQObu7oqJ+dndjhYXmEfXkyR32iFpOfYuUPPv9ApZWlOMLm6VEw0aUQCTC1e+/S7RBtaCWihgGk95/l0AkQjg2ji8c5pfyMv618PuE/nd9Wkq537+tznYgGqEqGOSm/324wzEIITKo7j7phrO7rTScDd7wPusORBK1SMnbP/9EIJJYVzcUjbCkbMsOj/vj5k2WiT4QifDmksUJ7bNWLk8o36mBuevXEknhA4MQIgO0hkmTrJO01uYRduMJZnXJetKk5Nez2ylJ1CIlniT3ChtaJ93WHG6HI27pzIZyHIn3Lzps1tetbUph62AzQIXo8LSG6mrr9s2bIS8v+QSz6mpJ1EI0ZNa2jk+cCuiVn0//QouJH800sGs3euTmJixGleNwcO7QfRP6n7bnkIRiK06bjXG77yGJWoj2xmaD6dNh+PD6hNxwdvfMmfGzweu2DR9uPq4NipxkUsd6NSLtTho0mBMGDsRtd5DjcJLrdNHN6+Wx409GpZAglVI8fsIpdM3JIdfpIsfhxG13cPKgwZywx6CE/tcfOop9evQkx+Ekx+HA63QyoGs37hhzZCovTwiRKV5vfLJueAtWXl78rVsNk7TXm+nIW53M+hYpsSnFvUeN45LhBzB33Vq6e3MZtWvfpLdQtcQe3brx5YWX8OmqFZT5fIzs3SfpUbrX6eSVM87mu40bWFK2hf6FRYzcuXdKHxaEEBlWl6wnTjQrjj34YP2s7rr7rCdNMk93d9AkDZKoRSvZrahrm9wG5bTbObL/7s3qq5Riv516sd9OvVo9DiFEhni9MGNGfU3vhlwumDbNPPXdwU53NySJWgghRHZrKglbJfAOpuN+BBFCCCE6AEnUQgghRBaTRJ0ma6q2MnfdWqqCgYzFoLXml7Iyvl2/jqBFkZLGNtbUMHfdWsp8vjREJ4RIpy3ryln0xU9Ubt6a6VDEdsg16jZWHQxy2btvMXfdOlx2G6FolD8MG8mkgw5J64zk1Vu38vu3X2dN1VbsNhtaa+464mhOHjQ4oW8wEuGaD97l4+XLcNnthKJRbt11dwyt5Z5kIdq5UCDEPec/xOz/zsPpdhIKhhk7YQxXTrsIWweekNWeyU+ljV3/4Uy+WbeWYDRCdShEMBrlyW/n8uaSn9IWg9aa377+KksryvFHItSEQtSGw9z4vw/4cfOmhP5//ayUj5cvJxiNbou5IuDn/+bPTVvMQoi2Mf26Z5n9zjxCgTC1W32EA2E+fLaU1/7+dqZDE0lIom5DVcEApSuXE4pG49r9kQhPzP8mbXHM37COMr8voRZ2OBrlue8XxLVFDYNXf/yBYDT+1LjWmqcWzGvrUIUQbSgajfL+058Q8ofj2oO+EP/5xzsZikpsjyTqNlQVDGJPcqq4wu9PWxzlPr/lafao1myqrYlrCxtRwkY0oS+Yp/GFEO1XJBQhErKen1JTKXNRspUk6jbUKy8frzNxbVS7Uhy6a9+0xbF/r50JRxOTb47DwRH9dotr8zicSat/Dd+5d5vEJ4RID3eOm957WBcE2vvQxNK8IjtIom5DdpuNO0uOxONwbFtcwmmzk+9yc/VBh6Qtju5eL38YNjJu8QyP3c7O+QWcNnivhP53jTkKj8Ox7WyAI7YC1c2jSswOhpF8dRqtze1CiKz0x0f/gNvrwmY33/7tDjs5+R4u+fsFGY5MJCOzvtvYuD0G0is/nyfmz2XV1koO7LMLv99/BD3z8tIaxzUHH8q+O+3Es999y9ZAgGMHDOS8ofuR40xcMvLAPrvw+vhzeXzeN/xctoV9e+7EAG1jULfu4PNZ190Fc8H2TlB3V4j2bN/Re/HQ13fzyn1vsmLRavY8YABnXX8yvXbrmenQRBKSqNNg3516Me24EzMdBkf2373ZdbMHdevO3485dtv3paWl9Ul6XmxS2dVXm0XxXS4zSV99tblwO5j9JFkLkZX6770rf3rmykyHIZpJTn2L5jGM+iRdXGx+zZplJueamvokXbdt3jyzvxRLEUKIlEiiFttnGLBqVX2SriuCX5esx42rT9INt9Ula7lmLYQQO0wStdg+paxXr6lLyDU19Um6sfz8Dr+yjRBCtCVJ1GL7lIJddoHRo2Hz5vgZ30pBUVF8Mtba7Dd6tDnhTBK1EELsMJlMJixNm/MVj879hkAkTJ7LxW39BpgTxxpei44l4MpAgKUV5YSjURSavqEIPY87DlU30ayBmlCIaXO+4o0li1HAqXsO4YoDDsZrMfu8La2vrub+rz5n1srl5DldTNhvGOfvu7/UMhdCZJ20HlErpXoqpT5L53OKlrvz00944Osv8UfCaKA6FGJdVRXP/LgIpkwxj6ArKwGz+triLZsJRaNoIM/nZ7XdxvmHHJiQpKOGwdmvvcSM775lU20tG2treWrBfM7+98sJ5U3bUrnfx4kvPcdbSxZT7vezqmor9335GTf+74O0xSCEEM2VtkStlCoCngFy0/WcouUMw+CZ77613Pbgp6UweTJUVEBhIQDLKivi+lTl5NDF7+eYxx5nfVlZ3LbSlctZsbUyrvZ5KBplWUU5n69a2aqvoynPf/8dtaEQ0QYfDvyRCG8uWcy66qq0xSGEEM2RziPqKDAekHfCLFYZCFge3SqtufaV1xJOeyesa60UZbm5HLh0Gb4rLjfvr45ZtGkjvnD8YgAAgXCEhZs2tu4LacI369YQtCip6rbb+WnLlrTFIYQQzZG2RK21rtJaywrlWa7A40ls1JqdKrdy0NJlCbO7HUpR4PMlTDAry82l9/xvzUplsW19CrpYXovOcTroU1DQ6q8lmd2KuloulhIxDHqnMQ4hhGgOpdN4bRBAKVWqtS6xaL8YuBigZ8+ew1966aWkY9TU1JCX5hKcncnyygpqGxwJA/RRNvI2bMDhdse1R0MhgmjshibS4BYupcCLgtxc6NcPMJfK/KlsC9FG91XbbTb27N4dRXomcoWiUX4pL6Ph775SCo/Dwe5FXdMSQ3PJ73r6yT5PP9nnpjFjxszTWo9o3J41s7611o8DjwOMGDFCl5SUJO1bWlpKU9tFag4zDM7598vMW79uW9vtu+zGKd98U1/0BLbdgjX11JPpfscdHPDrUspyc/E4HOxjs+MYMSKhjGjfinKu/eA9fty8CYC9evTkgaOOoV+SFbvaSsGa1dzw0ftsqK1BaxjTrz/3HjWWLlZnFDJIftfTT/Z5+sk+b1rWJGqRPRw2G6+eeQ41oRCrtlawW1E3vv78czPpNqz1PXo0TJ3K1S4XxqjRbL30Unb7+mscNhsMH25Z63u3oq68Pv5cKgN+FCpjifGgPrvwyQUXUeb3k+NwkOtKXI5UCCGyQdoTtdVpb5Gd8lwuhhQ3WFHH661P1o1Wz7J5PBQ99lizV88q9OS0dfjbpZSiuywaIoTIcnJELVrG64UZM+prejfkcsG0aebkMauSo0IIIVpMErVouaaSsFUCF0IIscPksEcIIYTIYnJEnQZVwQBvLfmJtdVVDNtpZ8b0382ccNUKXvvxB1754Xs8DieXjTyAg/rs2irjbvH5uPeLT1laXsa+O/VilE5+lGxozWcrVzB77Rp65OZy0qA96ZqT/NrvkrItzPz1ZxSKYwcMZI9u3Vol5upggPu/+oKFGzcwsFt3Jh8yiq6d+Br05jVlfPzi59RurWXk2P3Z+7A9Ua1wtsMwDOZ98B3fz/qRrr2KOOI3h9Gle/L7z5cvWsVn//4apRSHn3EQfYfsknIMQnQmkqjb2OLNmzj7368QMaL4IxFynU76dink5TPOTmmmsWEYHPuvZ/mlvL5M5+erV3LG4L2YcvS4lGL+es0qzv3Pq9TdZbxg4wa67dSHXcvKGNAoqQYjES5489/bqo55HA7u/+pznj75NEbu3Cdh7GlzvuKRuXMIxyqDTZ83hytHHsSlIw9MKeafy7Zw/L+e3VYWdMHGDbz64yJeOn08I3snxtHRff76bO45758YhkE4FOH1f7zLgccP46Z/XY0thQ+JoWCYG8bexa/zl+GvCeDKcfHULS9y97s3sfdhgxP6v3DXa7x49+uEQxGUgpfufYPzbj2Dc244NZWXJ0SnIqe+29gfZ75DdSiIP1ZqszYcZmlFOdPnzklp3Oe+XxCXpOu8tvgHlldUWDyi+Sb+9y2syuD84b+vJ7S9uOh7vt+4YVtp0EAkgi8c5sr3/ptQinRZRTmPzJ1DIBIhqjVRrQlEIvxzztesqEwt5t+/9Xpc7W4ADVzy3zdTGrc9CviC3Hv+QwT9IcLBCGgI1AaZ/e63fPnmNymN/c7jH/Lz3F/x1wQACPlDBGoC3Dn+QYxGhWxWL1nLv+5+naA/hBE1iEYMQv4Qz9/xKmt/XZ9SHEJ0JpKo29CGmmpWVyVWTQ1Go7z58+KUxn5x0fdJtz357dwdHrcmFKIqFLTctnJr4mv5z08/EGhc7zs2zpKy+LrZ7y/9hUijN3MAQxt8uOzXHYzYtCbJYhqVwYBlfB3Z97N+xGZP/NMO1AT43wufpjT2h8/OIugLJbT7q/2sWLQ6ru2L1+cQjSTWVNeG5ss3UvvAIERnIom6DdmVzfLItG5bKppaN9mewqnNlj6yqdfhaLTNrmyWRUJtSqW8P5rS2X7JrZJ0HbvdntLY9iRja62xO+K32ew262viSmF3pBaHEJ1JZ3sPS6vi3Fz26NotITl5HA7OGLJXSmP/br9hSbddPGzkDo/rdbnomqQYyR5dEyd9jd9rH3IciVMdunpyGNA1vm72sQMGJv2AMXbAHjsQbb3dkpQgLfZ6cVnE15ENHT3EMkF6ct0cM2FMSmMfe9GReHLdCe1digvYdXD8XIBRZxyEzZYYh1Jw2GkHpBSHEJ2JJOo29s9jT6BrjpdcpxOnzYbX6WS/nr34/f4Jdddb5My99rGcrHXxsBEprwD17KmnJ6wupZRixsmnJ8YxZG9G7dqPHIcDp81GrtNJgdvN9BNOTkgWu3Tpws2jSnDb7XjsDjwOB267nT+PPoLe+anFPOOU03E1Olq0K8Uzp5yR0rjtkcvt5LZ/X4cn140n143T7cCd4+LoC0oYOW6/lMYee+EYhh89FE+uG4fLTk6eh7zCXP7yn+sTft69+vfkkr9fgMvjxJXjMr88Ti77x+/osWtxSnEI0ZmkffWs5hgxYoSeOzf5ddb2VsA9GInw0bKlrK+pZt+ddmJEr96tcpsMwBerVvLcwgXkOJxcecCB7FbUOrc6BSIRHpr9FT+XbWHYzjszuMbf5D7/buMGvlm7hu7eXMbuPoAci+Us66yvrt52TfqY3QewU15+q8QcMQwemzeHBevXM7i4mMtGHoSnnR9Np/K7XlNZy+f/mU3tVh8jxu7bqrdFLfnmVxZ+tpiinoUceuoBeLyJR9l1Nq8p2zaJ7dBTRtK9d+v8jraV9vb+0hHIPjcppSxXz5JELZpF9nlmyH5PP9nn6Sf73JQsUcupbyGEECKLSaIWQgghspgkaiGEECKLSaIWSVUFA/xctoXaUGKBi8ZC0Si/lJWxxedLQ2SiPTEMg28/Xsh3pT8kVC/LZj988RNz31/QrmIWHVP7nhIr2kQ4GuW20v/x+k8/4rDZiWqD2/rujtbacrb6qz8s5K7PSjG0JmwYHNxnV/4x7jgK3J70By+yyicvfs69F0zbVqHM7rRz43NXMfqsQzIcWXK+aj/HeX9DOGCWxbXZbVz24AROvuLYDEcmOis5ohYJ7v/qc95YsphgNEptOEQgEmGLz8dz3y9I6Pv1mtX8ZdbHVIdC1IbDhKJRvlq9iivf+2/6AxdZZfOaMv527j/iyohGw1HuOudByjekVtu9rQR8Adb+vH5bkgYwogbTrnqKXxcsz2BkojNrMlErpRxKqROUUgc0aj+zbcMSmWJozfPff5dQH1trzePzE+szPzbvm20LjtQJGVHmrF3D+urqNo1VZLenbn7ReoOGp295Kb3BNNOLd7+RdNv//en59AUiRAPbO6J+GTgOuF4p9aFSqq4U1qVtG5bIlFA0QjBqvYhFud+f0La+xjoZO+12NvtqWzU20b5sXr0l6bZNq5Jvy6SNKzYl3bZ5TeJqdUKkw/YSdZ7W+jKt9ZnAn4H/KKWOTENcIkM8Did9kpTzHNpjp4S2Q/rsitNiEZCoYTDAoja46DyaKld6wHH7py+QFjj01OQ1yIcfPTSNkQhRb3uJOlqXmLXWXwHjgBuAfds6MJE5fyk5Mq70pk0plFLcNGp0Qt9Lho8k1+XC0SBZ5zgcXH3gIXibKCMqOr7TrzkBb0HiAi+5hV5Oveq4DES0faNOOwi7K3GOrdPtZMJd52QgIiG2n6jPBgbWfaO1Lsc8FX5zWwYlMqukX39eOPVMSvr2Z9eCLozbfQ8GdO3K0J6JR9Q98/J455zzOWvIPuzapZARvXrzj3HH84fhO76Cl+gYHA4H/1o1nQOOG4bT7cDpdnDgCcP416rp2FJYirWt9d97F0rGH4LL48ThtLNvyV48v/xhvHnWq8oJ0daavD1La10FPNqoLQxMb8ugRObt32tnnjr5tG3fl5aWJu3bKz+fu444Kg1RifYmt8DLX/97Y6bDaBGlFDe/OCnTYQixTfZ+rBVCCCGEJGohhBAim0miFkIIIbKYJGohRMdnGKC19Tatze1CZKmkk8mUUjbgWK31O7Hv99Ja/xD7vwO4Vmt9b3rCbHtlPh+PzJ3N/5YtpcDt5sL9h3PyoMGWta1b6rOVK3hk7mzWVlcxoldvrjrwYPoVFln2/XTlcm7++CM21FTjdbq4dMQBTByR/N7OtjJv/Voemv01yyrL2au4Bye7c9Meg4hXW+Xj1fvepPSVr3B5nJw48RiOu/go7HZ7pkNrNY9Pfo63p39AOBCi9x69+NMzVzBwxADLvku/W8Fzt7/K0gUr2GVwb8679QyGHDQwsaPPBxMnQn4+PPgguFz120IhmDQJqqth+nTwelsc89wPvuPFu//DppVb2OuwPfntn8+g94Beln3X/LyO5+54lR+//Jme/Yr5zU2nMewo6/uz2/Ln/cOXS3j+zldZs2Q9A/bvz29vO5PdhvZNeVzRNpRO8ilTKWUHPtZaj44l7Y+01kfEttmAD7TWbTLVd8SIEXru3LlJt5eWllJSUtJqz1cVDDDuhWco8/kIxz5Z5zgcnL33UG49fExKY7/24yL+XPq/bSU57UqR43Tyxvhz2a2oa1zfT5Yv5aK330gY4zd7D+WuI45OKY6W+GTFMi5/9+1tMSvgml67cNjhh7OvxS1aou3U/a6HgmEuHXY965dtIhw061C7vW4OOmE4t7zUMWYo/2nsncz/8Pu4NqXgkXlTGLBf/7j2H7/+mclH3UHIH6LuPcyd4+K2/1zPyLH71XesS9Lz5pnfjx4NU6eayToUgquvhlmzzG3Dh8P06ZTOmdPs95f3Z3zCQ1f8H0GfucKczW7Dk+vm4Tn30GfgznF9V/20lisOvIFgbRDDiMXsdXH1Y5dw1LmHx/Vty5/37Hfnc+eZfyfoN2NWSuHKcfH3T/7CoJHWH4raWmu/p7dXSql5WusRjduTnvrWWkeBaOz/BhBpsM0AkpxHan9eXPg9lf7AtiQN4I9EeGHhd2yu3fEymBHD4K+flcbVzY5qjS8cZurXXyb0v+njj6zjW/Q9oYh1Wc/WprXmL6Ufx8WsY+1/+6w0LTGIRJ+++hWbVpdte9MGCPqCfP32XFb+uDqDkbWOLevKE5I0mGelH/jDowntj137DEFfkIYHGkF/iIeveqq+U8MkXVxsfs2aZSbnmpr6JF23bd48s38zT4NHI1GmX/vMtiQN5gIegZoAz9z2ckL/Gbe+SKBBkgYI+kI8evUMotFoXN+2+nlrrZl25ZPbknRdW9AXZPq1z+zwuKJtbe8a9Uil1Hyl1LdAsVLq27ovOlCi/mL1KgIW9a3ddjsLN23c4XHXV1cTiib+0Rta8826tQntm2prLMfRwA+bk9cgbk3BaIS11VWW21LZFyI1Cz5ZRKAmkNCubIrFX/+SgYha15x35yfdtvKHNQltv8y3Xslq3a8biIQjZrJtmKSVMr/qkvW4cfVJuuG2efNg1apmJetNq7cQCSW+bxiGZuFnPyW0L/r8J7SR+LYZ9AcpWxe/mlhb/bxDgVDSOuu/zF+2w+OKtrW9RD1Xaz1Ma71/46+0RJcmfQoKsFtci44amp65O35tttDjIaqt/+B75uUltLmauPbUp8C6/nZrc9kdceVDG+qaI5WZMqVnv2Kc7sSSrDabjW47W893aE/6Du6TdFtuYeLfYEH3fMu+njw3dofdTLz5Fn3qEnJNTX2Sbsxms25vHEO3fKIR67/v7r27JrR17WX9c9KGJr8o/jW21c/b6Xbi8liX9u3SPT3vMaLlkiZqpZQTcMb+f1DsSPrLuq+0RZgGF+w3DGejJOlQir6FhQwp7rHD4+a73Rw7YCBue3ziy3E4uMxigth5++xnOU6/LoUU5yYm9rZgU4rz9tkvIVkrpZg4PP2T2oTp2AuPwO6I/3O12RS5XbwM6wCLRex16J7kWSRkgPNuPSOhbfz1J+HxuuPa3F4Xp151nDkBVClz4tjo0bB5c/yMb6WgqCg+GWtt9hs9GnbZpVmJOrfAy+FnHJSQ+Dy5bs658dSE/r+56bSEmF05Lsaccxg5jcqTttXP22azcdJlY3F7XXHtbq+b8X86ZYfHFW2rqSPqYmCCUqo/sCF2JH2I1voQYDTQYaaaDurWnYfGnUC3nBy8Ticuu51hvXoz45TTU571ffeRR3PM7rvjstvJdTrJdTq57pBRHLP7Hgl9bz68hCP77xbX1ju/gDfGn5tSDC113SGHcfrgvXDHYs5xOCj25nLuPrIWS6Z0792Nv75zE8V9uuH2unF5nOy+f3/+Puv2DjPre/q3U+hS3OCoTsEJE4/mpEvHJvQ95crjOPWPx+HOcZGT78HlcTL2d2M4/y9n1XdyucyJY1bJuqGGSXrq1GYl6TqTHr+EQ045AKfbSU6+h5w8D7/76zkcekrih9rDzziYC+4YjyfPQ06+B6fbyWGnHsBVD/8+oW9b/rwv/OtvOPr8ElweM2a3180Z157AiROPSWlc0XaamvX9BvAtUAr8A/i04WYgX2s9oS2CSves7zpRw2Dl1kryXW6KUzjlbaUy4KfM56NPQRfcSU4t16kKBJi3fi0DunZjly6FrRpHS1QHg2ysraF3fgGzv/hCZmVmQOPfda0165ZuwOVxUdynYy4junLxGjYs38S+JUPweD1N9vXXBti0agvFfbrhzU9yaaamxrwmXVNjHkk3VlEBeXkwcybk5e3Q+0tVeTWVm6rYqX8PXBanrBsKBUJsWLGZop5dyC9q+kxZW/68a6t8bFlbTs++xQlH+ukms75NyWZ9J80YWutTlFK3AZcCRwKPAEHMpK2AzP5k24DdZku4Zaq1FHpyKPQ07xpvgcfDmP67t0kcLZHvdpPv7nA/5nZNKZX0Ht2Oou/gPk1es24oJ9fTdN9QCCZPNpNxcbF1n8JC84h68mTziHoHFHTNp6Cr9XXzxlweF7vu2btZfdvy551b4CW3oOX3jYv0a3Iymdb6duBfWusyzCUvPwe+11rP1Vp/kY4AhRBihzS8TzrZxDGInw1+9dXJT5ELkSFNJupYBbK3lVLXxJpCsWUuhRAie2ltVhyzStJam0fYjSeY1SXr1aslWYus0tSsbxvwvjYvYo8HhgGXK6WGxb52fDq0EEK0Ja3NsqBW7Zs3m9ekk00wa6ouuBAZsL37qOvK5XQFTgC6x/49EXij7cLqWIKRCG8tWcxj8+Ywe81qkk3g2xHLKsp58tt5PP/9Arb4fE32Xb21kmvff5c/vPU67y9t/0UyRMfjq/bzwTOlvHLfmyz55tcdH8hmM2t3Dx9en5Abzu6eOTN+NnjdtuHDYddd+e6zxVw6YjK/32cSHzxb2mqvLxqN8o/LnuB3g//ITcf9lfINFdt/kOj0mpp+/B6wr1LqbWCl1vp2pVSJ1voOpZQXWJ+eENu3ZRXljH/tJQKRCMFoFJfdzt49evLMyadvd/b39jzw1Rc8MX8uGo1dKf722SweOOZYxu2RuDDB9LlzmPLlZ9u+/9+KZQwo6srMcy/AZpNF1ETmLZm7lD8dfQfRqEE4GMbhdDBi7L7c+so1LbslyTDMU9ler5msG9b6PvxweOAB8HjMiWMWtb7X/ust/npxfdnS+yY8zDO3vcwLyxNLmbbE5rVlnNvvUnTU/KC+Zsk6xu98MdfPuJxjzi9JaWzRsTVV63sssEhrfWKDZqWUug74s9b68TaPrgO4auY7lPv91IbDRAwDXzjM9xs28H/zk99+1hwLNqznyW/nEoxGCEWj+CMRAtEI13z4HlXB+NKDVYFAXJKu82tFOQ9983VKcQjRGgzD4C+nTqF2q49ATYBoOErQF2TeB9/x4bOfbn+AOj4fTJgAV1xhTiarS9bDh8OoUeaR88UXm/3q7rMuKdmWpJcsWodva+KZqU0rt/D8na+m9BqvPuyWbUm6ofsvfCSlcUXH19Q1agXcF1tFa16sUtk7wFSt9Q3pCrA921xby6/lZQlF0QPRCK8uXpTS2G8uWUywUSF/MFfnKl0RXwf5uYULko7z8g8LU4pDiNawfOEqai0SZKA2yHtPWi9Wk6DhIhylpebRcl2yfvxx83T4Z5/VL75Rl6ynTYMZM8Dr5fE/PZd0+DcfnrlDr63OppXWNba1oVn0RWJtcCHqNHXO06O1ngn8U2v9J+BkwK+1jsC2EqOiCYbWJKtxZDS8Tr0Di9pHDW15rVs3HjvWN2mMTWwTIl2MqEGyPxbD4ig0wfZWyrrmGuuVsnw+8zR57PJPU38PVgtqtJZoJPFDtxB1mkrU/1FKvQWMjf17AXCHUuqt2HXrt9ISYTvWMy+PXbp0SWh32+2cMmiw+U3jU3UNhUJm+4QJZr8GThg4yHLxjKhhMLpv/Nq95zVR+vO0wUOa9VqEaEu77dvXsjqW2+vmmAtKmn5wKitlNVrW8nd3np30acZeeMSOvjwg+aIcKNh39F4pjS06tqauUR8LzAXWApOBk4Cngfu11ifGtreIUurJ2KIet+xowO3NP8adQIHbTU4sqXqdTgZ07cbEEQcmP1UH9cUaSkvjP/3HjNy5N2cO2ZschwMbCqfNhttu564xR1HUaJWrrl6v5SIgvfPzuebgw9rmhQvRAna7nVtfuRZPngdXjrlghCfPw5BDBnLsRdtJkKmslJWfH9c+9PAhePISy5Z2KS7gD/ec16LX1NiDn95uedbgsqkXpjSu6PiS1voGUErtDgwFDgbuBXrGHvNDi59IqdOAk7TWE5RSjwAPaq0t7xHKVK3vtlIdDPLfX5awrrqK/Xr2oqRff+yBQPxRANTfOjJlilnOsO4ooG5bbMIL3vqyf4s2beSjZUvJcTo4fo9B9ClIPIJv2Pcfs79kayDIKXsO5uy99mn2jO/2ts87is6237duqeKTF7+gYmMl+5bsxf5H7tO8hXGaW4UMEhfhcMWvJFVaWore6OCZ214hHAxzwsVHc86Np6X0uur4a/zcN+FhFs/+heI+3bj2qcuaXS61I+tsv+fJJKv13WSibuUA/gnM1Fq/q5Q6A3NRj6et+na0RJ3AMMzT2Q1P1UH9G0hRUX1t4sbbhg83J76k+Zaqdr/P2ynZ7y3QnGS9nSQNss8zQfa5KRsS9ZOYE9O+U0odAwzTWt/TYPvFwMUAPXv2HP7SSy8lHaumpoa8vPSsz9xmVq0yKyc5LebkRSJgdY91OGyeqtt117aPr5EOsc/bIdnvLWQY8MsvEI1a/w1FImC3wx57JP2wK/s8/WSfm8aMGdOy1bPaQA1Qd/E0j0bXx2P3ZT8O5hF1U5+uOsSnr1Y8VZcOHWKft0Oy31tAjqjbLdnnTUvn+dN5QN3MpX2BFWl87uyzo4vaZyBJC5H1dnSlrMZ3WgiRhdKZqN8AfquUegA4C7N4SpsLR6NsqKkmGIlst6/Wms21tVQHg2mIDDPpTpliXpOurLTuU1lpbp8yJWmS/rlsC2uqtjbrKauDQTbX1jar3ngwEmFDTTVhi8Iq2UrrMDq6Aa1b/w3YiKzGCDevRrrWgVgcrb/vjPAvGJG1zYvDqEFHNzfv5x2oZfOqnwiH/KmGmDY1W2uY885cAhMv3+5KWRoIhyJmXYG6ZD1pUtIPyeuXb2TFD6ubFUfQH2TL2jKiGf5bqa3yUb6holk/71AwzJa1ZUTC239vzBaRcIQta8sIBbe/iKPWmvINFdRWNb0GQnuQtlPfWusqpVQJcDQwRWvdvMyy48/H4/O/4eE5s4loA4Xiwv2HMemgQ7FZfNr+cvUqbvjofTb7ajE0HN63H/cdPZZCT47F6K1kRxa1b5Cs/7P4B2783weEY/eBFrjcPH/amezdo2fCMBV+P9d9+B6fr1qFUtAzN48pR43lwD67JPQ1tOb+Lz/jme++RQMOm40/77p7K7zgtqO1Rtc+CbUPg46CUmjvBFTeHzEXgttxRuh7qJgAusb8Hid0uRtbzkkWcYTQVXeB/3VAgfKg8/+EzXt6SjEAGP7XYestgPkmZah8KHoWmyvxHlxtVKArJ0PoSzMOew/ocg/KlXibXjQa4enrr+GNx9aCBrtTc+6NQzjrhrtSjrmtRKNRfr/3NaxZsg6lNdfxDYMd1fTu3r3+77vB5Ez/itUs3+AnHI6ChoKiXHYtdmOvrjb7NXhPCPiCnFx0wbZSok6Xg2ufuowjfzMqIY5wKMwjf3yaD54pRSmF2+vi4vvOZ+yEMWnZD3Wqyqq594KHmP/RQpRSdNu5iOueuszy/mzDMHj65hd5/aH3QGvsTju//fOZnHHNiRYjZwetNa/c/xb/uuvfRCNRlE1x2tXHc8Ht4y3vXPn244X8/fePUr6hEm1oRo7dj+uevoyCrha38bUDaZ06rLWu0Fq/orXe0NbP9fIPC/nn7K+oCYcIRCL4I2Ge+nYej86dndB3WUU5f3j7ddZUVxGMRgkbUT5duZwL33q97QJM8VTdT1s2c92HM7claYCqUJDTXvkXkUaVzLTWTHjz33y+aiVhI0ooGmV11VYufOt1VlQmrt7z0OyveOa7b8364ZEINaEQG2treO3H1MqetiXtfxVqHgJdCwRA+6F2Brr2sZTGNYwQlI/flqRNYdh6HUZkaWIcVXeA/w0gGIujEqpuRwdnpRZH+GfY+ifqkrT5ZNVQfiaGEX9EpLVGl18US9JhIATRNeiKP6AjKxPGfv7Pf+KNx9YS9NsIBmz4qu08e+diZj5+f0oxt6VJo25lzZJ1AGil+CfD+CmSz7qvFiaslLXmn0/x8Vo73mAN2jDQ2kBVlDGvzG7e7tjgjT4UCrP6p7Vx9b7DoQj3nPdPVi5ekxDHtCuf5MNnZxEKhAn6Q1SV1fDQFf/HnPe+bfudEKO15sZxdzH/o++JhCKEg2E2LN/ELSfczdpfE9dOev7O13j9ofcI+oIE/SF8VX5m/Pll3p/xSdpibqn3nvwfz9/xKr5qP0F/iEBtkH8/+A4v3ZP4Hr16yVpuPeleNq7YTDgQJhKK8M37C7j5+LszEHnr6LDLJk375mv8jU53+yMRnpg3N+G00IwF8wk1OmUVNgyWbNnMT1s2t35wqSxqHztV97fPrN/4I4aRsODHj5s38Wt5eVxSBwgbUZ77bkFcm6E1T347L2Hfaa15aE4WL+BR8wjQ+JStH2r/L7VlRX3/R/1qr41U3Rv3rTZqwf8mEGjUMYCuSXHhhapkbzIR8D3VqGkxRJcSl9QBdBjtez6uKRqN8J+HlhP0x78VBP02Xrj7y9RibkOLv46/BBFUDv7BMBaH89GbN8fN63j9qU95lKF8TzGFBCkkyC+6kHt9e7N8afzf96tT3iShOH/M45Pj64D7a/x89NynBP3xl1mCvhAv3PVa6i+ymZYuWMGqn9YSCTV6DwtFEuqTG4bBvx/4L0Ff/OW9oC+Y1phb6oW7/k2gNjHmV+5/K+Hv+42H3iMSiv/dj4QiLF+4iuULEz+otgcdNlEnW5u5OhRMSFjLKyuIWryZO2w21lZXtX5wqSxqHztVt7qJa9K/VpTFfb+2ugq7LfGIPWIYLKssj2sLxs4+WNnsq036nBlnWC94YB4Jb/96VlIWR83bRFc1iqGMpH9S0eZdU07KaOJaaeMYo2sBq2UhIxCJX7AlFKgh4LeOuWJjMwqNZJG6ZB3eZ6i5IlbsUtHqJesIRhWPsh/f0YOfKeIfDCPqcrGx0UIZq35K/nPasHRj3PeVm6qw2a333caVbfABP4mNKzdbxhENR7eddagTCoQJ+Kzn4JSvr2yL8FpFxcZKy3bfVn/CNfbVS9YRjSSuj+Bw2hJ+3u1Fh03UA7t1t2zvXVCAq9HatiN37oPbYr3bYDTKkO49Wj+4VBa1j52qG7Fz76TDj2lU63uv4p6WE8I8dgcH9o6/Ru1xOCjOzbUcd88k+zQrOPawbrf3RqkUZsq7myix6mp0u6N9J1BWCVKBM3m99WZxJtxaWc89ulHfIWA5mc4NrpHxLTkFdO2R+KYG0H+v7H17SFatLKgcuP71grkiVmw+x9DDB+PyOIkoG9PYj/sZSVA5CAUi7L5fv7jHDz9mv6TPufeowXHfd+/T1TJBKqXY88Akv49tYMD+/QkHEyeEuXJcDG10jdqd40pac7z/0L5tEl9r6LeXde2Inn2Lcbria1HU/bwbs/p5txfZ+5eYopsOG52waIXH4eCWUSUJfX87dD/yXC7sDf74cxwOThk0mF5WNYRbQ8N1chudqiMvL/7WLYvyoTceenhcvHW65eRw/MA949p6FxRwwh6DttUbB3AoRZ7bxTl7D43rq5Ti1lElCftOKcWNoxolhCyi8m8AGtdo9kDejSmNa8s5FVShxRYH5E+Oj0G5IO8aUA0nICpQOai8P6YUBwWTsTxKtnXFlnNcfBz23pBzPPVlC2Lx2vJR3vhFJ2w2GxPvOxp3TsNkrXHnGFw85dzUYm5DJ1x6jGX7oaceYH4QbvC3cdJl4/Dm52B3mO1aKdxeN0edN4riPt3iHn/M+aOxORLfFu0OO3+4N35/OF1OLvzrObgbLCailLmQyAW3j0/l5bVIz77FlJx9SFwcdoed3IIcjr/4qLi+SikufeAC3N74D69ur4tL7vtt6wa2A6sCJnPJ/efjzmkUc46LiQ9ckNA37udd1zfJz7u9SFtlspZorRKi89av5e9ffsHP5Vvo16WISQcfwqG7WH9q3FBTzQNffUHpiuXkuVxM2G8Y5w3dz3KGeKuqW5gjPx8efDD+FqxQyLwmXV2dUOMbYHlFBZe++xa/lJVhU3Bwn12ZfvxJeC1u44oaBs99v4BnvvuW2lCII/rvxqSDDqVnkmpAn61cwYNff8mqqkr27FbMufmFHHv00a360lubDs1H1zwI4V/A0dec8e0+JOVxDaMWKi6D8BzAAMcgKHwIm8P6d0kH3jevSUc3gms/VN4klHPQDj13w991I7ICKq6A6C+ADZwHQdHD2GzehMdpHUX7XgDfc+bpf/cRqLyrUPbEOwIAvnnnBZ79yxusXxGl/15Ofnfn+QwZdfwOxZwuj09+jn8/+F+MqIGyKY696AgmPTbRsu+WtWXM+PPLzH53PrkFXk696lhOvHSs5Yzhjz/+hPfv+YwFn/yA1pr+e+/Kn/99Lb1372U59mf/mc0Ld73GlrXlDD5oIBfedTb990nv0Wk0GuWth2fyxrSZ+Kr9HHTCcC64fTzdd+5q2X/uB9/x7G0vs27ZRnYbuisT7jyHIQcNbL2AWvi+1pz39B++XMLTt7zIih9W03uPnbjg9rMZduQ+ln1b8vPOJhkvIdoSHb7Wd2OGUb/8XmN1p74z/AvW4fZ5tmr0uxC337Pkd6Gjk9/1FDVcFRDiizU1vNsFtp0pLJ0zR/Y5yRO1/MVng0an6uI0WNRedHA7uDa5EFmjYZIuLo6/tbSmJv6W1CRrgotEkgGEyAYprE0uRFYwjPgkXXdmqC5ZjxsXf0tq3bZ588xFiiRZJyWJWohMa+ooxDCSH4VIshbZRCnzmrRVe3GxeUSdrLhTU2cVhSRqITJqe0chv/yS/ChEThmKbKKUOXHMaqEhpcw1CxoXd6q722WXXSRRNyGdy1xmtepgkGe+m8/7S3+lyOPhgv2GcWT/7K5vLdJDawMC76B9L4IOQs5JKO/ZKOW27h9agK59AqJrwHUAKvcilH0n68G3dxQSjSY/CsnPT/rmprWG4P/QvufAqALPMSjvb1E261n+OvyTGXPkV3Dug8q9GOWwvndVG+Xo2qch+CnYeqJyL0S5D7LsG41EmfnUx7w/oxSlYNyFR3DMBSXYHVb3m4MOfmmObWwC92hU7gSUzXrmcktoowbtexYCH4CtEOW9AOVJbz3u9qpy81b+/eB/+WbmArr37soZ15zIfmP2tu5ctypgS5cb/TJ7q+BlA0nUQG0oxEkvPW+ushUrDDJv/XouHjaCPx6U+u09on3TVTeD/122lSit/gUd+C90fRGl4v+EDP9M2DoZs9a3hsgvaP8b0P0N8/7mxuqOQqze2JQChyP5UciDDyZP1DVToXZGfcw1v5pxdHsd1eh2Lh2cja64OBazAZGfY6/v5YTbyrRRjt5ygpn8CQGL0aHZ6PwbseXG36OttebWk+7l+09/3Faycul3K/nyrbnc8cbkhKIlRu3zUH1ffcyRpWj/f6D72yibdZGO5tBGLbrsVIhuiL1G0OFv0ZHfY8u7cofH7QwqN2/l4n2vo6aihnAwwtIFK1jwyQ9MfOACTrg4ye2adasCjhtXv/pfwsCV210VUNSTU9/Aqz8uYmNtzbYkDeCPhJk+bw7lfrkO2JnpyK/g/y/xdcQDEPkFgh/H99VRqPqLuX1bwegI6Bp0zT+TP0krr02uo1ug9slGMQchuh7tT1zEQFfdFutbdxo9CtqHrk6sL65rnwRjK2aSruOHmnvQOr405cLPFrPwsx/j6koHfUEWfLyQH7/6udFL80NNgyQN5nMYlejaGZavs7m0/zXznnaCDRuh5nG0UZ70cQJevf9tqstr4iqfBX1BHrvuWUKBJEvJNlwVsLDQuk9hobl98mRZE7wZJFEDHy9fRsBivWqX3c6CDW2+0JfIZqG5gNWpOx86+EV8W3S9mQASRCG4nVN7rbQ2OQDhBWBZNjUAwdK4Fq0DEF1hPU5ofmJbcBbWtdNtEIlPvt+V/kDQl/gmHAqE+a70h0YxL8G6PnkoIeYWC5aSuFAKoJwQ+i61sTu4b977lkgo8b3RZlMsX2RRf35HVwXMwnoe2UQSNbBTXp5lBbKo1nTzJlZ9Ep2IrVuS+t0usDVaQ9xWQNKVtrZ3nbU1j0Js3bBeAspm1iOP4wSSJH1bF4u2JOum63DCayzs0QVXTmLNZZfHSWGPRmPbuppjWMaRYr19e0+s3+oMsLfPkpLp0rVXoWV7JBShsLggvjGVVQFXr5Zk3QRJ1MD5++6fsFCHXSl65uYxtId1yUXRSbhHY53IbCjv6XEtylZg3V/loHJ/n/w5UlybPIFzv1iybvzn7UJ5f9NoSDvknIFlnXRvYh1llXsh8TXEARzmBLRG1+BLxh9iuWiFzWZj9FkHx4/r2BWcg0mcNpODyv1dwhgtoby/JfFnaANbT3BYl6AUptOvORGPN37SpMNpZ+CI3enZt9GHtlRWBWyqLriQRA2wd4+e/O2Io8lzushzuchxONijazeePfWMpKv0iM5BKReq63Ng62MutqFyQRWiih5G2RNrP6su94LrAMANKs/813sheE6wfoLtHYVEIttdmzwxZoUqmgH23YEcMw6VB13uRjkHJ/YvuAE8RwAuUPlmzDmnx5Jyo77uUZB/Tf24uMG5L6poWkLf/KI87n7vFrruVEhOnoecPA/dehVxzwe3kluQeKZKFT4Kzr3r953KgfzrU67Xrpx7QcGdsZ9dHuABxx6ork/L3/d2jBy7H7/7m7nwiLcgB1eOi0EHDOC2f1+X2DmVVQF33VUqMDZBZn3HnLLnEI4dMJCftmwm3+1mt6LUbwkRHYNyDoTi/8WuwYbAMThhtve2vrY8VNen0NF1EN0Ejt1RtiZWYNveUYjdbv5rdaQdW5vc6ghcOfqgit9BR5aCUQPOwUmX+1TKhSqcio5uMteydvRrcpa1LfcCdM6Z5v6wdU16GxfAXocM4sU1j7Hsu5WgYLehfZMujKDs3VDdXkFHVoFRDs5BKNX46H3H2Lwno3OOhfBicxUxx26tMm5ncNpVx3PsRUeyfOEqinp0odduTZxlrFsVMFmt74a3bkH9qoBz5rTxq2jfJFE34HY42Hcn6xVyROemlIIWrICl7DuDfeftd6w7CmlY9ATqj0L22MP8t+6Iu25bg7XJm4zD0fxaAMreA+zNux6sbF5w7desvjabjQH7999+x7qxHbsCyZP/jlLKBa4U1wXvpHJyPc1fXathsm68elZdsm5iVUCRSBK1EJnW1FHIl18mPwqRNziRrbxemDHDelVAlwumTZOV4FpA9pIQ2aAuWQ8fDiUl8fdJ1x2FlJRIkhbth6wK2GrkiFqIbCFHIUIIC5KohWgGbdSYhTN0CNyjUPYk9xMDhhEC3/9BZDm4x2DLOa7pscM/QniheU3bdQhKJUnEVgm8lRhGBHzPQmQxuA4Ez2lJJ30B5iS10DywdTf3h0q8X3pbX6MiVihFmfW7bYVJ+/pq/Lx0z+tsXl3OmHMO4YBxw5KPq7VZ3CXyMzj6g3NkRmZxR6NR5n/4PZtXlzHogAHsvm+/tMeQTarKqpn97nyUUhxw3P4UdG1iMmUbWr98Iws+XkReYS4HHLc/7hzr2vztgSRqIbZDB2ehK64CZQMMqIqi86/Hlpt4n7ER+hbKf8O2wieBNzGq74LuH2FrXGNbh9CVl0Nwttmg7GArgq7/Sr6IRxswIstgy4lsqzgWeBOq/4ZR/BG2RkVMtDbQVTfGap8rM2blga7PoRwDEsf2vQFVt1JfdSyK7vI3bDknJvT94s1vuP20+8wEDHz03Cx679GLpxZPTfjQoI1adMXvzCStDfNnY+8DXZ9v8oNAa9u0ajOTDv8z1RU1GFGzBOuwo4by51evxeHsfG+vHz43i6mXPLZt0ZVoxODaJydyxDmj0haD1pr/u+F53njoPZTNht2uUDYb97x/C3sesEfa4mhNcg5NiCZoo9pM0vhB18ZKhIag+u/o8M+JD6j4HQnVyYwtUDkpcezaGbEkHTC/dK1Zj7vymlZ/HU0qP5+EsqC6BsoT76Mm8BYEZmLWzY7FbJSjKy7blmC3DRFdH0vSQcAX+wrC1pvQ0Y1xfQ3D4M4z708YY+0v63n4j08nhKGrH4Dwj6B9sTh8EFmO3vqXFr30VN11zlS2rC3HXx0g6AsR9IWY/9H3vP7Pd9MaRzbYtHoLUyc+TigQxl8TwF8TIBQI8feLprNlXfpqqs/78HveeuR9QoEwQV8QX3WA2q0+bjnhbqKRJJUDs5wkaiGaEvwEy1rfhNGBN+NajPAvscRhIfRZYpv/ZRJrUEch/J15ujgNDMNnLilpJbI4oUn7/mVRz1ybi15El8U3B97DupQpEHg/7tsv3/yGaMR6be2Pnptl8fg3iF8YBCAMwQ/MZUnToGLTVn6dv2zbkXSdoC/Eu098lJYYssmnr36FNqx+3prPXvs6bXG8+8RHBGqDCe3hYIRFX/yUtjhakyRqIZqiQ6Cs3nwMMBolWcsFORr0txrbkkpe97rVNZXULF53spiVzVyrO65vEOva59GEvr5qi0Uz6npHrfZdsv1j0PRraj2RUCTpNfFQIF0/v+wRCoQxLI5YjaiR1v0R9Cf7HW2/PxdJ1EI0xT3KvAbamPKgcsbGtzn2Jum0D8feiW2eYzEXxWjE3scsPpIGNlueWVrTcqNFwRbPiSTWBQdwg6NRQRj3kVi+PhzgGRPXUnLWwdYnLoARR1sUKXGXkPj2pcA5PGnVuNbWvXdXuvdJXNTD6XYw+qzOt479wSeNwOFK3Pd2h52DThyetjiOOOcwPLmJE8eiEYN9RiWW0G0PJFEL0QRl7wn5kzCTkw1zAlUOuMeBc2RcX5vNBgV3WIzigMJ/JI6ddznYe4Gqm2TmBpWLKryvlV/FdnR50KLRBoUPJ7Sq3HPBMaBBzE7Agyr8u7nAR8O+zoHgPRdz3ylzTDzgPT9h4pnL42LC7eMTns+T6+a6py5NjKPgptjCI3UlRj2gClBd7mr6tbYipRQ3PHcVOXkeXB7ntnh79i3mNzedlrY4skX/vXflpMvH4fa6zHrzNoXb6+bUq46j7+A+aYujZPwhDDlkEJ488wOlw2nHnePi2v+7NGGBkfai801LFKKFbLkXol0Ho/1vgg6gPOPAdaDlaU+b9wwM595QdS8Y68wFOvKvx2YrSOirbF2g+zsQeAcdmgf2XVE5p6Ps3dPxsupj9pRgdP8Qqu4xrzM79ob8G7A5Em9BU8oD3V6GwIfo0Jdg64nynm6WTLUau+BPaM8xaP875mccz4moJGU8z73lDPYbszdP3fIiFRsqOeD4YVx41zm4PIk1ypV9J+j+Ptr/FkR+MBfZyDnV3KdpNPjAPZjx8z95/+lPWL98E/uMGszoMw+2jLkzuHjKbzns1AP45KUvUEox5pzDGHxgemda2x127n7vZua8+y2z35lHXtc8xk4YQ5892m95aNV4lmU2GDFihJ47d27S7aWlpZSUlKQvICH7PENkv6ef7PP0k31uUkrN01qPaNwup76FEPGaWhtYa3O7ECJtJFELIer5fDBhAlxxBYQazZ4Nhcz2CRPMfkKItJBELYQw+Xz1K3iVlpordtUl61DI/L601Nw+caIkayHSRBK1yAitQ+ik9xFnJ63DbRKzEYlgRJZhRJLfS7yjtI6gG9/fbKVhki4uNr9mzTKTc01N/TKbddtamKxb8vOORqME/c2IWYhOQhK1SCsdXYdRPgG9cV/0xn0xyi80S01mMW2UY1RcHot5KEbZOejIsu0/sBmMTafDliGwZRxsGYqxYRhGpCblcbVRg1F5PXrjfuZ+3nIKOrwoSRBGfJKuW/yjLlmPG1efpBtuq0vWTVyzbsnPOxQMM+3KJzm54HxOKjif3w3+Iws+SRKzEJ2IJGqRNloH0WVnQuhrzIpVUQh9iS47K2uPrrU20GXnxkqJRgADwvPRZePRxtaUxjbKfg/GwkatNbDl0JTGBdAVl8RKeIYAAyI/osvPQ0fXJXZWCvItVjiqS8g1NfVJurH8/KQrerX05z3lgod476mPCfpDGFGDNUvWccuJ97Ds+5UteelCdDiSqEX6BD4wF3GIK/FomAtABLK0NnLoazA2YCbpOhp0EO1/I7Wxw58m2eDHiOx4ctLhn81lMxvXwtZhtO/5xAcoBQ8+CKNHw+bN8TO+lYKiovhkrLXZb/Ro83HJlpZswc+7bH0FX741l1Cj8o/hQIiX7n1jey9ZiA5NErVIn+gK60UrtB+iWXrUFF0F2qpedQAiv7bd8wZTWMQguhIsy2iGwWrFLwCXC6ZOtU7WDTVM0lOnmo9LGseKZv+8N67YhMudWG7UMDQrf1yd/DmE6AQkUYv0cQyyriutcsCxZ/rjaQ7HwCRHjDko59C2e173ETv+WMfAJItWuMFpXRUMMJPulCnmEXRlpXWfykpz+5QpTSdpaNHPu8/AnQkHE2O2O2ztdg1hIVqLJGqRPu4jwNaD+IUanGDrBe7DMxVV05z7x5JKw6RkB1sBeI5PbWxPsnrQXS3LdzaXcvQF92jiF8+wmQuJeH+T/IGhEEyeDBUVUFho3aew0Nw+eXLifdaNteDnXdAtn3EXHYG7US1ml8fF+MknN/08QnRwkqhF2ijlQHV7GXJOBZVvfuWchur2YsKCDtlCKYUqehq8vwFVaB4heo5Ddfs3yubd7uObYiu8B1yNkr3aBbp/ntK4AKrwAci9yFy4QuWA+wgzZnviak9A/X3SDWd3Ww6s4m/daiJZt/Tnffk/LmTCHePp1rsrbq+LYUcN5R9f3MXOu+/U8h0gRAcii3KItFK2QnOFozSucpQqZfOaqzUV3NTqY9u6PghYrV6VGqVcqPw/Qv4ft99Za5g0yTpJa22e7i4srG9vmKwnTYJp05Im9pb8vG02G2dccyJnXHPi9mMWohORI2ohOjutobraun3zZsjLSz7BrLo6+cQzIUSrSFuiVkr1VEp9lq7nE0I0k80G06fD8OH1Cbnh7O6ZM+Nng9dtGz7cfJxNPu8L0ZbS8hemlCoCngEspoAKITLO641P1g1vwcrLi791q2GS9qZ2nV4IsX3p+igcBcYDVWl6PiFESzVM1iUl8fdJ191nXVIiSVqINGuTyWRKqceAQQ2aPtZa36GSzSQVIs20DqB9/4HgB2ArRHnPRblGts7Y4V/QvhkQWQXug1Hec1C2Iuu+Rjm69gUIzQFHP1TuBSjHgFaJoyV0ZBW69hmI/AwPDUXl/hblaHSftMtlThzTWk53i6wW9Af5YEYpn78+m4Ju+Zx02Tj2GTU402HtMKXTOBFEKVWqtS5Jsu1i4GKAnj17Dn/ppZeSjlNTU0NeXl6bxCisdax9riGylG11sFHml62neTtTSkPXmNXM0LEvm/nlGEDi5+JIrLqZER+Hve+2QiFp2e/aD9HljWJW4Nid+PvHO4eO9bvePrTmPtdas/qntYQCYbRh5jdlU3Tv3ZXCHl1a5TnaypgxY+ZprUc0bs+a27O01o8DjwOMGDFCl5SUJO1bWlpKU9tF6+tI+9yofRGqHwL8jba4UT2+QNkKdmhcrQ305sPB2NRoiwNyzsTW5fb4OLbeBP7XMa8MNWDrhSouRSmVlv1ubDkRIksatSpwlWDr+libPnc26ki/6+1Fa+7zt6d/wCvXzyToi18q1eVx8vK6J8grbH9TpeT8leh8gh+SmKQB5YTw/B0f11gPhtU0jEhs9a3GccwiIUkDGOVgbNzxOFpA6yBEfrHaAuEU6o0LkSFfvDEnIUkDOFwOfviy8QfS9iGtiTrZaW8h0spWhHmauTENKoVTYyoXy8QLYLNaRtKibVsc6frUbyfpibW0xSBE6+nSvQCr+VDa0OQXtc/faTmiFp2O8p4HuBu3mkm6qUUrtjeurRBcB5GQ+FQOeC9IfID3AiCnUaMT3IeirBJ7G1DKATknkngt2mOWTRWinTn58rG4cuJXYlMK8rvmseeB7XOBF0nUotNRrv0hfzLgAZUHygu2nVFdn0ap1P4kVOH94BgC5Jhj44KcM1A5Zyb29Y6HnFPMPirPjMe5F6rLlJRiaHHM+beC6wC27Q/c4DkKlTsxrXEI0RqGHDyIP9x7Hu4cF96CHHLyPPToW8y9H9yKrZ3erZA1k8mESCdb7nnonFMg/C2oAnAOtTxd1lLKVoTq/ho6/LN5zdoxBGW3XglLKRuqy+3ovMshstj8sOBM/yd+ZfOiuj6Fjiw314l2DETZd057HEK0lpMvP5ajfjuaH7/6mbzCXPY8YECr/H1niiRq0WkpWx64R7XN2M6BwMDm9bX3AHuPNomjJZSjPzj6ZzoMIVpFboGXkWP3y3QYraJ9ngcQQgghOglJ1EIIIUQWk0QthBBCZDG5Rt2JaB2B0GyzzKVrJMrWtfXGjm6A8AKzBKdzeMqzp9NBG+UQ+sa8n9l1gHmrUrK+OgShr0CHwHWweX07aV8N4e9ik8n2Rjl2aYvw2w0jWga+5wAFub/F1oq/d20lFAyz4ONFhINh9jtib3ILZAESkTmSqDsJHV6MLv8dEAQU6BA6bxK2vItSG1drdPU94HsBlAvQZkGRomeyOkEZNY9DzUNQl5xVDhQ9jXIOSuirQ9+gKyZi1sEGdBhdcAc276mJfaOb0RUXQHQdYDP75hyHKri7XXx4aW1G9QNQO72+ofZhjNwrsOVflbmgtsNfE+CsnX5P3ToIkXCUPz76B445vySzgYlOq/O9c3RCWkfRFReBLgddax5RE4Kaf6JDKZTMBAjOBP9L5ni6xhw/ug5deVlrhN4mdGgO1DwMBGP7oxaMLeiKi9DaiO9r+NAVF4Oujr2+GvNxVbeZtzM1HnvrtRBZAdpX39c/E+1LvshMR2WEf4pP0nVqp2FElqY/oGbw1wZY++t6arf68FX58VX5CflD/OPSJ1jz87pMhyc6KUnUnUForrlCUoIA2vdiSkPr2ucsxjYgshIdWZnS2G3FfM0Biw21ibW+rWp0AxBB+1+Pf7hRDqH5QKRRX3/s1G8nU/PQjm3LoNn/nbftxElD0UiUD5+dlf6AhEASdeega0la21pbLSLRkrFrrNuVPfm2TDOqsHw3RsX2VQO6FhodZZsiiQtw6ADW+5nEcTuDpn7+louXZJ6v2uIDHBANR6mu7IQ/Q5EVJFF3Bq4RoMMWG3JQnmNTG9szjsS62QB2cCRe780GynOseU26MR0G5/D4NvehmGtFNx7Ei/IcFd9m6wWWE6Uc4D56R8Ntv3JOa2LbGemLowWGHz3Ust2T6+GQk0amORohTJKoOwFlK4D8GwAP9T/yHHAOBs9xqY3tPR/sO1O/uIQd8KC63N3kLOqMyjkp9iGiLmYb4IGCWxJmcyt7b8i9KJbY646WveA6xPxq2FcpVJd7Y+PWLQrgAVt3VP7lbfVqspYt52Sw90vcYN8dW05qv3dtpWffYop6FuL2uqmrOOnJdTPsqH0YdtQ+mQ1OdFpZ+k4qWpst91y0a6g5qcnYivKMBc84lHJu/8FNULY86P4G2vcmhD4FWy9U7jkox4BWirz1KeWCrs9D4D104EOwFaG8Z6Oce1n2t+VfjXYfiva9BjqAyjke3EdZzuJW7oOg+9to378gugpcB6JyTm/ydq4OrdtM8E0H3yuAAu9Z4L0k01E1qdvORfzt3ZuY+dTHBP0hxpx9KIecPLLdLugg2j9J1J2Icu6D6tL6RwVK5aByz4bcs1t97LailAtyTkblnNy8/q6RKFfzTn0qx66oghtSCa/DsNlskHeZ+dWODD18CEMPH5LpMIQA5NS36KwMA7TVhDLMdsNqApkQQqSfJGrR+fh8MGECXHEFhELx20Ihs33CBLOfEEJkmCRq0bn4fDBxIsybB6WlcPXV9ck6FDK/Ly01t0+cKMlaCJFxkqhF59EwSRcXm1+zZpnJuabG/HfWrPptkqyFEFlAEnUnoXUQo+qvGBv3x9gwBKP8fHTk10yHlT6GEZekta5Eh+ehuyxD/+9J9FF90aWfmAlaKfOrYbKWa9ZCiAyRRN1J6IrLwfdSrEKWuYqWLhuPjm7KdGjpoRTk5wOgdS1EfgaiZns3G1TXQOFatt0821B+vnW7EEKkgSTqTkBHlkFoDubKWdtaQQfN+307A6XgwQdh9GjYsCR+xrdSUGgHFUEbW802rWHzZrP/gw9KohZCZIwk6s4gsrR+Occ4IQgvSns4GeNywdSpcIgHypLcnqWr45P01Knm44QQIkMkUXcGjv6gG6/oBOACZycr6uByoW87BAptsNWqhnc+VFZCURFMmSJJWgiRcZKoOwHlGGAuzNF48QzlQnnPzUhMGRMKoe52QaUBXRr/+jtQti5QWAgVFTB5cuJ91kIIkWaSqDsJVfRwbMWi2OISzpGori+h7D0zHVr6xO6TVp//AD0HxV8OUF5w7Rv7v4q/dUuStRAig6TWdyehVA6qy23Q5Ta01qjONjlKa5g0adt90kopsHdDA0pr83R3ob1+gayGyXrSJJg2TSaUCSEyQo6oO6FOl6TBTNTV1QnNqm7iWF6e+a/VBLPq6uR1wYUQoo1Johadg80G06fD8OH1Cbnh7O6ZM81/G28bPtx8nCxxKITIEHn3EZ2H1xufrBvegpWXZ/5bl6wbJmmvN9ORCyE6MUnUonNpmKxLSuLvk667z7qkRJK0ECJryGSyHTRv/Vpe+/EHApEIJwwcxJh+u2HrQNd+dXQz2veSWWrTuR/QL8MRtSKvF/30ExD8AO2bDP6uKO9ZKOeeZrKeNs089S2nu1OmtYbQl+jAWwAozyngOqhzzpMQYgdJot4B/5z9FY/Nm0MgEkEDHy77ldF9+zHt2BM7xBuQDv+ELv8N6BAQguAsiFyGju6JsvfOdHgp0zqErrwAwj8BPsCG9r+GLvgzNu8Z9YtyiJTpqr9A4A3QfvP7wEzIOQNVcGsmwxKiXZFDhhZaW13Fo3Nn448laQBfOMyslSv4YvWqjMbWWvTWm0HXAHX3DweAKLrq3gxG1Yr8/4XwYswkDWAAAai6A23UZDCwjkWHfwT/69uStNnoB9+r6PCSzAUmRDsjibqFPl+10vIUty8c5sNl7X/ZSK1DEPnBaguEPk17PG1BB94F/IkblAPC89MeT4cVnEX9h72GIrFtQojmkETdQl6n0zJRO5Qir0PUhbYB9iTb3Ena2xlbXpINGlROWkPp0FQO1lfXHGYlOCFEs0iibqEj+u2GVekLh93OaXu2/wUulHKA52jA2WiLDbxnZiKkVqdyzsYspZqwAZzD0h5Ph+U5jqRvMZ5j0xqKEO2ZJOoWynW5eOKEU8h1ushzuch1unDb7dx2+BHs3rVbpsNrFargDnDsCeSAygU8oHJReVdlOrRWodwHQd7FgMt8fSoXVFdU0f+hVLKzCaKllL0HdLkP8/cnL/aVgyp8AGXvGH8rQqSDzPreAQfvsivf/GEiX6xaRTAa4dBd+tLF48l0WK1G2Qqg22sQWQiRleAYBPZ1KNURTu2bbHmXo3POgtAcsBXEbhlqfBZBpMqWMxbtPhRCXwAKXIeibLmZDkuIdkUS9Q7yOJwcudvumQ6jzSilwDnU/AJgXUbjaQvKXgw5x2c6jA5P2fLAMzbTYQjRbsmpbyGEECKLSaIWQgghspgkaiGEECKLyTVqIToowzAg+CZEyyHnFGytONNaG1shvAhs3VHOQa02rhAikSRqITogI/gZVFwMRM2GmnsxPKdiK0y9DKxR8wjUPArKCTqKdvQ1b22z90h5bCFEojY/9a2U6qKUek8p9aFS6nXVke7xESILGUYEKv7AtiRdJ/A6hv/NlMbWgY+h9jEgGKsH74fIL+iKy1IaVwiRXDquUZ8LPKC1PhrYAIxLw3MK0Xn5X8JcaMRCzbSUhta+GfGLbAAQhcjP6MjqlMYWQlhr81PfWutHGnxbDGxq6+cUolMzmvgTM6pTHLvCul05QG8FdkltfCFEglY/olZKPaaUKm3w9edY+8FAkdb669Z+TiFEAzmnJN/mHpXa2O4jAKurVxocA1MbWwhhSWlttcREKz+JUl2BD4DTtdYrk/S5GLgYoGfPnsNfeumlpOPV1NSQl5dsBSTRFmSfZ8YO7/foitg15IZssRruqXw+j0LkV/NfDECZX7adwVaYwrjZQ37X00/2uWnMmDHztNYjGre3eaKOTR57F7hXa/1hcx4zYsQIPXfu3KTbS0tLKSkpaZ0ARbPIPs+MVPa7UfMk+J4CHQDXYdDldmytkEy1UYX2vQjBUrD3QnkvQLn2TXncbCG/6+kn+9yklLJM1Om4PesiYDhws1LqZuBRrfXLaXheITo1W95FkHdRq4+rbAWovEsg75JWH1sIkSgdk8keBR5t6+cRQgghOiIpISqEEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJkMUnUQgghRBaTRC2EEEJksTZfj1q0T9qoRvvfhMivKOfeQLdMhySEEJ2SJGqRQEeWo8vOAh0C/Gi/FyKXoqN7o+zFmQ5PCCE6FTn1LRLorTeDrgL8sRYfEEFX35vBqIQQonOSRC3iaB2C8HxAN94Cwf9lIiQhhOjUJFGLRlTsy4pcKRFCiHSTRC3iKOUEdwmJSdkGOSdnICIhhOjcJFGLBKrgLrDvAioX8IDygvKg8q7JdGhCCNHpyLlMkUDZu0H39yD0JURXgmMQ2GtQNm+mQxNCiE5HErWwpJQN3IcBh8VaSjMYjRBCdF5y6lsIIYTIYpKohRBCiCwmiVoIIYTIYpKohRBCiCwmiVoIIYTIYpKohRBCiCwmiVoIIYTIYpKohRBCiCwmiVoIIYTIYpKohRBCiCymtG687nDmKaU2Ayub6NId2JKmcIRJ9nlmyH5PP9nn6Sf73NRXa13cuDErE/X2KKXmaq1HZDqOzkT2eWbIfk8/2efpJ/u8aXLqWwghhMhikqiFEEKILNZeE/XjmQ6gE5J9nhmy39NP9nn6yT5vQru8Ri2EEEJ0Fu31iFoIIYToFNplolZKdVFKvaeU+lAp9bpSypXpmDoDpVRPpdRnmY6jM1BKPamU+lIpdUumY+lM5Hc8feR9vPnaZaIGzgUe0FofDWwAxmU4ng5PKVUEPAPkZjqWjk4pdRpg11ofAuyslNoj0zF1BvI7nnbyPt5M7TJRa60f0Vp/GPu2GNiUyXg6iSgwHqjKdCCdQAnwSuz/HwOHZS6UTkV+x9NI3sebz5HpAJpDKfUYMKhB08da6zuUUgcDRVrrrzMUWofVxD7PVEidSS6wNvb/KmBABmPpNLTWVQDyO55e8j6+fe0iUWutL2ncppTqCjwEnJ7+iDo+q30u0qYGyIn9P492euZLiO2R9/HmaZdvALFJB68AN2qtm6oJLkR7NI/60937AisyF4oQbUPex5uvXSZq4CJgOHCzUqpUKTU+0wEJ0YreAH6rlHoAOAt4J7PhCNEm5H28maTgiRBZKDYD+WjgU631hkzHI4TIHEnUQgghRBZrr6e+hRBCiE5BErUQQgiRxSRRCyGEEFlMErUQHZhSaqZSKlcpZYt9/4FSyq6Usjfoo5RSbyql+jSut6yUcjTsK4RIP0nUQnRASqkBSqk/AxGtdS0wVin1MbA/8D7wUYOkfBuwALPIyiexW2VqlFKlwCfAcU08jyxiIUQbaxeVyYQQLTYUOAroo5R6FLhKa/2eUuq/WusTAJRSNqXUycAQ4FHA0FofGtu2QGtd0tQTyCIWQqSHHFEL0TEdAkwEftRaXwr8NXZE7VVK/aqU+ga4BngLuAyYCuhY3eVtYqfJkxW/lkUshEgDOaIWomO6FygDUEqdBdyqtQ7Gvv8LZrWz+YACHgE+01ovU0r9B9gv1u8jzPeIK4GFjZ9AFrEQIj0kUQvRMfUAbsSsGf4B8Eel1PGABvoBJwIPA04g1OBxgbr/aK2PSlewQojkJFEL0THZgDeBgVrrfyqlnABa6ymxI+r/aq3nKqXcmIuATMhYpEKIJsk1aiE6IK31Qq31rAbfh4HuSqncRv2CmKe/VeNbs2DbNWpnmwcshEhKErUQHZszdtSM1noycB4wDljToI8byMe8basmdm16S+zfD4HrmnqC7c0OF0KkRhblEKITUUopLX/0QrQrkqiFEEKILCanvoUQQogsJolaCCGEyGKSqIUQQogsJolaCCGEyGKSqIUQQogs9v/qISMH2UoV4QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入必要的库\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import adjusted_rand_score\n",
    "from sklearn.datasets import load_iris\n",
    "\n",
    "# 加载数据（以鸢尾花数据集为例）\n",
    "data = load_iris()\n",
    "X = data.data\n",
    "y = data.target\n",
    "\n",
    "# 标准化特征\n",
    "scaler = StandardScaler()\n",
    "X_scaled = scaler.fit_transform(X)\n",
    "\n",
    "# 创建 K-Means 对象，设置为3个簇\n",
    "kmeans = KMeans(n_clusters=3, random_state=42)\n",
    "\n",
    "# 训练模型\n",
    "kmeans.fit(X_scaled)\n",
    "\n",
    "# 预测簇标签\n",
    "y_kmeans = kmeans.predict(X_scaled)\n",
    "\n",
    "# 评估聚类效果（使用调整兰德指数）\n",
    "ari = adjusted_rand_score(y, y_kmeans)\n",
    "print(f\"\\nK-Means 调整兰德指数 (ARI): {ari:.2f}\")\n",
    "\n",
    "# 确定最佳簇数示例（肘部法则）\n",
    "inertia = []\n",
    "k_range = range(1, 11)\n",
    "for k in k_range:\n",
    "    kmeans = KMeans(n_clusters=k, random_state=42)\n",
    "    kmeans.fit(X_scaled)\n",
    "    inertia.append(kmeans.inertia_)\n",
    "\n",
    "# 绘制肘部图\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(k_range, inertia, 'bo-')\n",
    "plt.xlabel('簇的数量 (k)')\n",
    "plt.ylabel('惯性 (Inertia)')\n",
    "plt.title('肘部法则确定最佳簇数')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "# 可视化聚类结果\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=y_kmeans, cmap='viridis', marker='o')\n",
    "centers = kmeans.cluster_centers_\n",
    "plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75, marker='X', label='簇中心')\n",
    "plt.title('K-Means 聚类结果')\n",
    "plt.xlabel('特征 1')\n",
    "plt.ylabel('特征 2')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1167a5bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "随机森林分类器的交叉验证准确率: [1. 1. 1. 1. 1.]\n",
      "平均交叉验证准确率: 1.00\n"
     ]
    }
   ],
   "source": [
    "# 导入交叉验证方法\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# 创建随机森林分类器\n",
    "rf_cv = RandomForestClassifier(n_estimators=200, max_depth=6, min_samples_split=2, min_samples_leaf=1, random_state=42)\n",
    "\n",
    "# 进行 5 折交叉验证\n",
    "cv_scores = cross_val_score(rf_cv, X_train_scaled, y_train, cv=5, scoring='accuracy')\n",
    "\n",
    "print(f\"\\n随机森林分类器的交叉验证准确率: {cv_scores}\")\n",
    "print(f\"平均交叉验证准确率: {cv_scores.mean():.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f3185c31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "模型已保存为 'random_forest_model.joblib'\n",
      "加载的随机森林分类器的准确率: 1.00\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "以随机森林为例，展示以下\n",
    "保存和加载模型的过程\n",
    "使用 joblib 或 pickle 保存训练好的模型，以便以后使用。\n",
    "\"\"\"\n",
    "\n",
    "# 导入 joblib\n",
    "import joblib\n",
    "\n",
    "# 保存模型\n",
    "joblib.dump(grid_search_rf.best_estimator_, 'random_forest_model.joblib')\n",
    "print(\"\\n模型已保存为 'random_forest_model.joblib'\")\n",
    "\n",
    "# 加载模型\n",
    "loaded_rf = joblib.load('random_forest_model.joblib')\n",
    "\n",
    "# 使用加载的模型进行预测\n",
    "y_pred_loaded_rf = loaded_rf.predict(X_test_scaled)\n",
    "\n",
    "# 评估\n",
    "accuracy_loaded_rf = accuracy_score(y_test, y_pred_loaded_rf)\n",
    "print(f\"加载的随机森林分类器的准确率: {accuracy_loaded_rf:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c9aae318",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征列名: Index(['Sepal.Length', 'Sepal.Width', 'Petal.Length', 'Petal.Width'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 假设我们有一个 DataFrame iris_df，包含了鸢尾花数据\n",
    "iris_df = pd.read_csv('iris.csv')  # 读取数据集\n",
    "\n",
    "# 定义特征和目标变量\n",
    "X = iris_df[['Sepal.Length', 'Sepal.Width', 'Petal.Length', 'Petal.Width']]  # 特征\n",
    "y = iris_df['Species']  # 目标变量\n",
    "\n",
    "# 划分训练集和测试集\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# 打印特征列名\n",
    "print(\"特征列名:\", X.columns)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c6c988fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最佳参数: {'max_depth': None, 'n_estimators': 50}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "\n",
    "model = RandomForestClassifier(random_state=42)\n",
    "param_grid = {'n_estimators': [50, 100], 'max_depth': [None, 10, 20]}\n",
    "\n",
    "# 进行网格搜索\n",
    "grid_search_rf = GridSearchCV(estimator=model, param_grid=param_grid, scoring='accuracy')\n",
    "grid_search_rf.fit(X_train, y_train)\n",
    "\n",
    "# 确认模型训练完毕\n",
    "print(\"最佳参数:\", grid_search_rf.best_params_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f45d1779",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最佳参数: {'max_depth': None, 'n_estimators': 50}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# 假设你在这里定义了模型和参数网格\n",
    "model = RandomForestClassifier(random_state=42)\n",
    "param_grid = {'n_estimators': [50, 100], 'max_depth': [None, 10, 20]}\n",
    "\n",
    "# 进行网格搜索\n",
    "grid_search_rf = GridSearchCV(estimator=model, param_grid=param_grid, scoring='accuracy')\n",
    "grid_search_rf.fit(X_train, y_train)\n",
    "\n",
    "# 确认模型训练完毕\n",
    "print(\"最佳参数:\", grid_search_rf.best_params_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d87f6122",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# 读取数据集\n",
    "iris_df = pd.read_csv('iris.csv')\n",
    "\n",
    "# 定义特征和目标变量\n",
    "X = iris_df[['Sepal.Length', 'Sepal.Width', 'Petal.Length', 'Petal.Width']]\n",
    "y = iris_df['Species']\n",
    "\n",
    "# 划分训练集和测试集\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# 创建随机森林模型并进行网格搜索\n",
    "model = RandomForestClassifier(random_state=42)\n",
    "param_grid = {'n_estimators': [50, 100], 'max_depth': [None, 10, 20]}\n",
    "grid_search_rf = GridSearchCV(estimator=model, param_grid=param_grid, scoring='accuracy')\n",
    "grid_search_rf.fit(X_train, y_train)\n",
    "\n",
    "# 获取特征重要性\n",
    "importances = grid_search_rf.best_estimator_.feature_importances_\n",
    "feature_names = X.columns\n",
    "\n",
    "# 检查特征名称和重要性数组的长度是否一致\n",
    "if len(feature_names) != len(importances):\n",
    "    raise ValueError(f\"Length mismatch: {len(feature_names)} features vs {len(importances)} importances\")\n",
    "\n",
    "# 创建 DataFrame 存储特征重要性\n",
    "feat_imp_df = pd.DataFrame({'Feature': feature_names, 'Importance': importances})\n",
    "feat_imp_df = feat_imp_df.sort_values(by='Importance', ascending=False)\n",
    "\n",
    "# 可视化特征重要性\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.barplot(x='Importance', y='Feature', data=feat_imp_df, palette='viridis')\n",
    "plt.title('Feature Importance in Random Forest Classifier')\n",
    "plt.xlabel('Importance')\n",
    "plt.ylabel('Feature')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "8c93d941",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import seaborn as sns\n",
    "\n",
    "# 设置字体为 SimHei，解决中文乱码问题\n",
    "matplotlib.rcParams['font.family'] = 'sans-serif'\n",
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']  # 设置字体为 SimHei\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False  # 解决负号'-'显示为方块的问题\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92abc2da",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mathjian",
   "language": "python",
   "name": "mathjian"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
